strongdm.models

    1# Copyright 2020 StrongDM Inc
    2#
    3# Licensed under the Apache License, Version 2.0 (the "License");
    4# you may not use this file except in compliance with the License.
    5# You may obtain a copy of the License at
    6#
    7#     http://www.apache.org/licenses/LICENSE-2.0
    8#
    9# Unless required by applicable law or agreed to in writing, software
   10# distributed under the License is distributed on an "AS IS" BASIS,
   11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12# See the License for the specific language governing permissions and
   13# limitations under the License.
   14#
   15
   16# This file was generated by protogen. DO NOT EDIT.
   17
   18import collections
   19
   20
   21class AKS:
   22    __slots__ = [
   23        'bind_interface',
   24        'certificate_authority',
   25        'client_certificate',
   26        'client_key',
   27        'egress_filter',
   28        'healthcheck_namespace',
   29        'healthy',
   30        'hostname',
   31        'id',
   32        'name',
   33        'port',
   34        'port_override',
   35        'remote_identity_group_id',
   36        'remote_identity_healthcheck_username',
   37        'secret_store_id',
   38        'tags',
   39    ]
   40
   41    def __init__(
   42        self,
   43        bind_interface=None,
   44        certificate_authority=None,
   45        client_certificate=None,
   46        client_key=None,
   47        egress_filter=None,
   48        healthcheck_namespace=None,
   49        healthy=None,
   50        hostname=None,
   51        id=None,
   52        name=None,
   53        port=None,
   54        port_override=None,
   55        remote_identity_group_id=None,
   56        remote_identity_healthcheck_username=None,
   57        secret_store_id=None,
   58        tags=None,
   59    ):
   60        self.bind_interface = bind_interface if bind_interface is not None else ''
   61        '''
   62         Bind interface
   63        '''
   64        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
   65        self.client_certificate = client_certificate if client_certificate is not None else ''
   66        self.client_key = client_key if client_key is not None else ''
   67        self.egress_filter = egress_filter if egress_filter is not None else ''
   68        '''
   69         A filter applied to the routing logic to pin datasource to nodes.
   70        '''
   71        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
   72        '''
   73         The path used to check the health of your connection.  Defaults to `default`.
   74        '''
   75        self.healthy = healthy if healthy is not None else False
   76        '''
   77         True if the datasource is reachable and the credentials are valid.
   78        '''
   79        self.hostname = hostname if hostname is not None else ''
   80        self.id = id if id is not None else ''
   81        '''
   82         Unique identifier of the Resource.
   83        '''
   84        self.name = name if name is not None else ''
   85        '''
   86         Unique human-readable name of the Resource.
   87        '''
   88        self.port = port if port is not None else 0
   89        self.port_override = port_override if port_override is not None else 0
   90        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
   91        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
   92        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
   93        '''
   94         ID of the secret store containing credentials for this resource, if any.
   95        '''
   96        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
   97        '''
   98         Tags is a map of key, value pairs.
   99        '''
  100
  101    def __repr__(self):
  102        return '<sdm.AKS ' + \
  103            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  104            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  105            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  106            'client_key: ' + repr(self.client_key) + ' ' +\
  107            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  108            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  109            'healthy: ' + repr(self.healthy) + ' ' +\
  110            'hostname: ' + repr(self.hostname) + ' ' +\
  111            'id: ' + repr(self.id) + ' ' +\
  112            'name: ' + repr(self.name) + ' ' +\
  113            'port: ' + repr(self.port) + ' ' +\
  114            'port_override: ' + repr(self.port_override) + ' ' +\
  115            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  116            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  117            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  118            'tags: ' + repr(self.tags) + ' ' +\
  119            '>'
  120
  121    def to_dict(self):
  122        return {
  123            'bind_interface': self.bind_interface,
  124            'certificate_authority': self.certificate_authority,
  125            'client_certificate': self.client_certificate,
  126            'client_key': self.client_key,
  127            'egress_filter': self.egress_filter,
  128            'healthcheck_namespace': self.healthcheck_namespace,
  129            'healthy': self.healthy,
  130            'hostname': self.hostname,
  131            'id': self.id,
  132            'name': self.name,
  133            'port': self.port,
  134            'port_override': self.port_override,
  135            'remote_identity_group_id': self.remote_identity_group_id,
  136            'remote_identity_healthcheck_username':
  137            self.remote_identity_healthcheck_username,
  138            'secret_store_id': self.secret_store_id,
  139            'tags': self.tags,
  140        }
  141
  142    @classmethod
  143    def from_dict(cls, d):
  144        return cls(
  145            bind_interface=d.get('bind_interface'),
  146            certificate_authority=d.get('certificate_authority'),
  147            client_certificate=d.get('client_certificate'),
  148            client_key=d.get('client_key'),
  149            egress_filter=d.get('egress_filter'),
  150            healthcheck_namespace=d.get('healthcheck_namespace'),
  151            healthy=d.get('healthy'),
  152            hostname=d.get('hostname'),
  153            id=d.get('id'),
  154            name=d.get('name'),
  155            port=d.get('port'),
  156            port_override=d.get('port_override'),
  157            remote_identity_group_id=d.get('remote_identity_group_id'),
  158            remote_identity_healthcheck_username=d.get(
  159                'remote_identity_healthcheck_username'),
  160            secret_store_id=d.get('secret_store_id'),
  161            tags=d.get('tags'),
  162        )
  163
  164
  165class AKSBasicAuth:
  166    __slots__ = [
  167        'bind_interface',
  168        'egress_filter',
  169        'healthcheck_namespace',
  170        'healthy',
  171        'hostname',
  172        'id',
  173        'name',
  174        'password',
  175        'port',
  176        'port_override',
  177        'secret_store_id',
  178        'tags',
  179        'username',
  180    ]
  181
  182    def __init__(
  183        self,
  184        bind_interface=None,
  185        egress_filter=None,
  186        healthcheck_namespace=None,
  187        healthy=None,
  188        hostname=None,
  189        id=None,
  190        name=None,
  191        password=None,
  192        port=None,
  193        port_override=None,
  194        secret_store_id=None,
  195        tags=None,
  196        username=None,
  197    ):
  198        self.bind_interface = bind_interface if bind_interface is not None else ''
  199        '''
  200         Bind interface
  201        '''
  202        self.egress_filter = egress_filter if egress_filter is not None else ''
  203        '''
  204         A filter applied to the routing logic to pin datasource to nodes.
  205        '''
  206        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  207        '''
  208         The path used to check the health of your connection.  Defaults to `default`.
  209        '''
  210        self.healthy = healthy if healthy is not None else False
  211        '''
  212         True if the datasource is reachable and the credentials are valid.
  213        '''
  214        self.hostname = hostname if hostname is not None else ''
  215        self.id = id if id is not None else ''
  216        '''
  217         Unique identifier of the Resource.
  218        '''
  219        self.name = name if name is not None else ''
  220        '''
  221         Unique human-readable name of the Resource.
  222        '''
  223        self.password = password if password is not None else ''
  224        self.port = port if port is not None else 0
  225        self.port_override = port_override if port_override is not None else 0
  226        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  227        '''
  228         ID of the secret store containing credentials for this resource, if any.
  229        '''
  230        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  231        '''
  232         Tags is a map of key, value pairs.
  233        '''
  234        self.username = username if username is not None else ''
  235
  236    def __repr__(self):
  237        return '<sdm.AKSBasicAuth ' + \
  238            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  239            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  240            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  241            'healthy: ' + repr(self.healthy) + ' ' +\
  242            'hostname: ' + repr(self.hostname) + ' ' +\
  243            'id: ' + repr(self.id) + ' ' +\
  244            'name: ' + repr(self.name) + ' ' +\
  245            'password: ' + repr(self.password) + ' ' +\
  246            'port: ' + repr(self.port) + ' ' +\
  247            'port_override: ' + repr(self.port_override) + ' ' +\
  248            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  249            'tags: ' + repr(self.tags) + ' ' +\
  250            'username: ' + repr(self.username) + ' ' +\
  251            '>'
  252
  253    def to_dict(self):
  254        return {
  255            'bind_interface': self.bind_interface,
  256            'egress_filter': self.egress_filter,
  257            'healthcheck_namespace': self.healthcheck_namespace,
  258            'healthy': self.healthy,
  259            'hostname': self.hostname,
  260            'id': self.id,
  261            'name': self.name,
  262            'password': self.password,
  263            'port': self.port,
  264            'port_override': self.port_override,
  265            'secret_store_id': self.secret_store_id,
  266            'tags': self.tags,
  267            'username': self.username,
  268        }
  269
  270    @classmethod
  271    def from_dict(cls, d):
  272        return cls(
  273            bind_interface=d.get('bind_interface'),
  274            egress_filter=d.get('egress_filter'),
  275            healthcheck_namespace=d.get('healthcheck_namespace'),
  276            healthy=d.get('healthy'),
  277            hostname=d.get('hostname'),
  278            id=d.get('id'),
  279            name=d.get('name'),
  280            password=d.get('password'),
  281            port=d.get('port'),
  282            port_override=d.get('port_override'),
  283            secret_store_id=d.get('secret_store_id'),
  284            tags=d.get('tags'),
  285            username=d.get('username'),
  286        )
  287
  288
  289class AKSServiceAccount:
  290    __slots__ = [
  291        'bind_interface',
  292        'egress_filter',
  293        'healthcheck_namespace',
  294        'healthy',
  295        'hostname',
  296        'id',
  297        'name',
  298        'port',
  299        'port_override',
  300        'remote_identity_group_id',
  301        'remote_identity_healthcheck_username',
  302        'secret_store_id',
  303        'tags',
  304        'token',
  305    ]
  306
  307    def __init__(
  308        self,
  309        bind_interface=None,
  310        egress_filter=None,
  311        healthcheck_namespace=None,
  312        healthy=None,
  313        hostname=None,
  314        id=None,
  315        name=None,
  316        port=None,
  317        port_override=None,
  318        remote_identity_group_id=None,
  319        remote_identity_healthcheck_username=None,
  320        secret_store_id=None,
  321        tags=None,
  322        token=None,
  323    ):
  324        self.bind_interface = bind_interface if bind_interface is not None else ''
  325        '''
  326         Bind interface
  327        '''
  328        self.egress_filter = egress_filter if egress_filter is not None else ''
  329        '''
  330         A filter applied to the routing logic to pin datasource to nodes.
  331        '''
  332        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  333        '''
  334         The path used to check the health of your connection.  Defaults to `default`.
  335        '''
  336        self.healthy = healthy if healthy is not None else False
  337        '''
  338         True if the datasource is reachable and the credentials are valid.
  339        '''
  340        self.hostname = hostname if hostname is not None else ''
  341        self.id = id if id is not None else ''
  342        '''
  343         Unique identifier of the Resource.
  344        '''
  345        self.name = name if name is not None else ''
  346        '''
  347         Unique human-readable name of the Resource.
  348        '''
  349        self.port = port if port is not None else 0
  350        self.port_override = port_override if port_override is not None else 0
  351        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  352        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  353        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  354        '''
  355         ID of the secret store containing credentials for this resource, if any.
  356        '''
  357        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  358        '''
  359         Tags is a map of key, value pairs.
  360        '''
  361        self.token = token if token is not None else ''
  362
  363    def __repr__(self):
  364        return '<sdm.AKSServiceAccount ' + \
  365            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  366            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  367            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  368            'healthy: ' + repr(self.healthy) + ' ' +\
  369            'hostname: ' + repr(self.hostname) + ' ' +\
  370            'id: ' + repr(self.id) + ' ' +\
  371            'name: ' + repr(self.name) + ' ' +\
  372            'port: ' + repr(self.port) + ' ' +\
  373            'port_override: ' + repr(self.port_override) + ' ' +\
  374            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  375            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  376            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  377            'tags: ' + repr(self.tags) + ' ' +\
  378            'token: ' + repr(self.token) + ' ' +\
  379            '>'
  380
  381    def to_dict(self):
  382        return {
  383            'bind_interface': self.bind_interface,
  384            'egress_filter': self.egress_filter,
  385            'healthcheck_namespace': self.healthcheck_namespace,
  386            'healthy': self.healthy,
  387            'hostname': self.hostname,
  388            'id': self.id,
  389            'name': self.name,
  390            'port': self.port,
  391            'port_override': self.port_override,
  392            'remote_identity_group_id': self.remote_identity_group_id,
  393            'remote_identity_healthcheck_username':
  394            self.remote_identity_healthcheck_username,
  395            'secret_store_id': self.secret_store_id,
  396            'tags': self.tags,
  397            'token': self.token,
  398        }
  399
  400    @classmethod
  401    def from_dict(cls, d):
  402        return cls(
  403            bind_interface=d.get('bind_interface'),
  404            egress_filter=d.get('egress_filter'),
  405            healthcheck_namespace=d.get('healthcheck_namespace'),
  406            healthy=d.get('healthy'),
  407            hostname=d.get('hostname'),
  408            id=d.get('id'),
  409            name=d.get('name'),
  410            port=d.get('port'),
  411            port_override=d.get('port_override'),
  412            remote_identity_group_id=d.get('remote_identity_group_id'),
  413            remote_identity_healthcheck_username=d.get(
  414                'remote_identity_healthcheck_username'),
  415            secret_store_id=d.get('secret_store_id'),
  416            tags=d.get('tags'),
  417            token=d.get('token'),
  418        )
  419
  420
  421class AKSServiceAccountUserImpersonation:
  422    __slots__ = [
  423        'bind_interface',
  424        'egress_filter',
  425        'healthcheck_namespace',
  426        'healthy',
  427        'hostname',
  428        'id',
  429        'name',
  430        'port',
  431        'port_override',
  432        'secret_store_id',
  433        'tags',
  434        'token',
  435    ]
  436
  437    def __init__(
  438        self,
  439        bind_interface=None,
  440        egress_filter=None,
  441        healthcheck_namespace=None,
  442        healthy=None,
  443        hostname=None,
  444        id=None,
  445        name=None,
  446        port=None,
  447        port_override=None,
  448        secret_store_id=None,
  449        tags=None,
  450        token=None,
  451    ):
  452        self.bind_interface = bind_interface if bind_interface is not None else ''
  453        '''
  454         Bind interface
  455        '''
  456        self.egress_filter = egress_filter if egress_filter is not None else ''
  457        '''
  458         A filter applied to the routing logic to pin datasource to nodes.
  459        '''
  460        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  461        '''
  462         The path used to check the health of your connection.  Defaults to `default`.
  463        '''
  464        self.healthy = healthy if healthy is not None else False
  465        '''
  466         True if the datasource is reachable and the credentials are valid.
  467        '''
  468        self.hostname = hostname if hostname is not None else ''
  469        self.id = id if id is not None else ''
  470        '''
  471         Unique identifier of the Resource.
  472        '''
  473        self.name = name if name is not None else ''
  474        '''
  475         Unique human-readable name of the Resource.
  476        '''
  477        self.port = port if port is not None else 0
  478        self.port_override = port_override if port_override is not None else 0
  479        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  480        '''
  481         ID of the secret store containing credentials for this resource, if any.
  482        '''
  483        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  484        '''
  485         Tags is a map of key, value pairs.
  486        '''
  487        self.token = token if token is not None else ''
  488
  489    def __repr__(self):
  490        return '<sdm.AKSServiceAccountUserImpersonation ' + \
  491            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  492            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  493            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  494            'healthy: ' + repr(self.healthy) + ' ' +\
  495            'hostname: ' + repr(self.hostname) + ' ' +\
  496            'id: ' + repr(self.id) + ' ' +\
  497            'name: ' + repr(self.name) + ' ' +\
  498            'port: ' + repr(self.port) + ' ' +\
  499            'port_override: ' + repr(self.port_override) + ' ' +\
  500            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  501            'tags: ' + repr(self.tags) + ' ' +\
  502            'token: ' + repr(self.token) + ' ' +\
  503            '>'
  504
  505    def to_dict(self):
  506        return {
  507            'bind_interface': self.bind_interface,
  508            'egress_filter': self.egress_filter,
  509            'healthcheck_namespace': self.healthcheck_namespace,
  510            'healthy': self.healthy,
  511            'hostname': self.hostname,
  512            'id': self.id,
  513            'name': self.name,
  514            'port': self.port,
  515            'port_override': self.port_override,
  516            'secret_store_id': self.secret_store_id,
  517            'tags': self.tags,
  518            'token': self.token,
  519        }
  520
  521    @classmethod
  522    def from_dict(cls, d):
  523        return cls(
  524            bind_interface=d.get('bind_interface'),
  525            egress_filter=d.get('egress_filter'),
  526            healthcheck_namespace=d.get('healthcheck_namespace'),
  527            healthy=d.get('healthy'),
  528            hostname=d.get('hostname'),
  529            id=d.get('id'),
  530            name=d.get('name'),
  531            port=d.get('port'),
  532            port_override=d.get('port_override'),
  533            secret_store_id=d.get('secret_store_id'),
  534            tags=d.get('tags'),
  535            token=d.get('token'),
  536        )
  537
  538
  539class AKSUserImpersonation:
  540    __slots__ = [
  541        'bind_interface',
  542        'certificate_authority',
  543        'client_certificate',
  544        'client_key',
  545        'egress_filter',
  546        'healthcheck_namespace',
  547        'healthy',
  548        'hostname',
  549        'id',
  550        'name',
  551        'port',
  552        'port_override',
  553        'secret_store_id',
  554        'tags',
  555    ]
  556
  557    def __init__(
  558        self,
  559        bind_interface=None,
  560        certificate_authority=None,
  561        client_certificate=None,
  562        client_key=None,
  563        egress_filter=None,
  564        healthcheck_namespace=None,
  565        healthy=None,
  566        hostname=None,
  567        id=None,
  568        name=None,
  569        port=None,
  570        port_override=None,
  571        secret_store_id=None,
  572        tags=None,
  573    ):
  574        self.bind_interface = bind_interface if bind_interface is not None else ''
  575        '''
  576         Bind interface
  577        '''
  578        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
  579        self.client_certificate = client_certificate if client_certificate is not None else ''
  580        self.client_key = client_key if client_key is not None else ''
  581        self.egress_filter = egress_filter if egress_filter is not None else ''
  582        '''
  583         A filter applied to the routing logic to pin datasource to nodes.
  584        '''
  585        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  586        '''
  587         The path used to check the health of your connection.  Defaults to `default`.
  588        '''
  589        self.healthy = healthy if healthy is not None else False
  590        '''
  591         True if the datasource is reachable and the credentials are valid.
  592        '''
  593        self.hostname = hostname if hostname is not None else ''
  594        self.id = id if id is not None else ''
  595        '''
  596         Unique identifier of the Resource.
  597        '''
  598        self.name = name if name is not None else ''
  599        '''
  600         Unique human-readable name of the Resource.
  601        '''
  602        self.port = port if port is not None else 0
  603        self.port_override = port_override if port_override is not None else 0
  604        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  605        '''
  606         ID of the secret store containing credentials for this resource, if any.
  607        '''
  608        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  609        '''
  610         Tags is a map of key, value pairs.
  611        '''
  612
  613    def __repr__(self):
  614        return '<sdm.AKSUserImpersonation ' + \
  615            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  616            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  617            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  618            'client_key: ' + repr(self.client_key) + ' ' +\
  619            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  620            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  621            'healthy: ' + repr(self.healthy) + ' ' +\
  622            'hostname: ' + repr(self.hostname) + ' ' +\
  623            'id: ' + repr(self.id) + ' ' +\
  624            'name: ' + repr(self.name) + ' ' +\
  625            'port: ' + repr(self.port) + ' ' +\
  626            'port_override: ' + repr(self.port_override) + ' ' +\
  627            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  628            'tags: ' + repr(self.tags) + ' ' +\
  629            '>'
  630
  631    def to_dict(self):
  632        return {
  633            'bind_interface': self.bind_interface,
  634            'certificate_authority': self.certificate_authority,
  635            'client_certificate': self.client_certificate,
  636            'client_key': self.client_key,
  637            'egress_filter': self.egress_filter,
  638            'healthcheck_namespace': self.healthcheck_namespace,
  639            'healthy': self.healthy,
  640            'hostname': self.hostname,
  641            'id': self.id,
  642            'name': self.name,
  643            'port': self.port,
  644            'port_override': self.port_override,
  645            'secret_store_id': self.secret_store_id,
  646            'tags': self.tags,
  647        }
  648
  649    @classmethod
  650    def from_dict(cls, d):
  651        return cls(
  652            bind_interface=d.get('bind_interface'),
  653            certificate_authority=d.get('certificate_authority'),
  654            client_certificate=d.get('client_certificate'),
  655            client_key=d.get('client_key'),
  656            egress_filter=d.get('egress_filter'),
  657            healthcheck_namespace=d.get('healthcheck_namespace'),
  658            healthy=d.get('healthy'),
  659            hostname=d.get('hostname'),
  660            id=d.get('id'),
  661            name=d.get('name'),
  662            port=d.get('port'),
  663            port_override=d.get('port_override'),
  664            secret_store_id=d.get('secret_store_id'),
  665            tags=d.get('tags'),
  666        )
  667
  668
  669class AWS:
  670    __slots__ = [
  671        'access_key',
  672        'bind_interface',
  673        'egress_filter',
  674        'healthcheck_region',
  675        'healthy',
  676        'id',
  677        'name',
  678        'role_arn',
  679        'role_external_id',
  680        'secret_access_key',
  681        'secret_store_id',
  682        'tags',
  683    ]
  684
  685    def __init__(
  686        self,
  687        access_key=None,
  688        bind_interface=None,
  689        egress_filter=None,
  690        healthcheck_region=None,
  691        healthy=None,
  692        id=None,
  693        name=None,
  694        role_arn=None,
  695        role_external_id=None,
  696        secret_access_key=None,
  697        secret_store_id=None,
  698        tags=None,
  699    ):
  700        self.access_key = access_key if access_key is not None else ''
  701        self.bind_interface = bind_interface if bind_interface is not None else ''
  702        '''
  703         Bind interface
  704        '''
  705        self.egress_filter = egress_filter if egress_filter is not None else ''
  706        '''
  707         A filter applied to the routing logic to pin datasource to nodes.
  708        '''
  709        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
  710        self.healthy = healthy if healthy is not None else False
  711        '''
  712         True if the datasource is reachable and the credentials are valid.
  713        '''
  714        self.id = id if id is not None else ''
  715        '''
  716         Unique identifier of the Resource.
  717        '''
  718        self.name = name if name is not None else ''
  719        '''
  720         Unique human-readable name of the Resource.
  721        '''
  722        self.role_arn = role_arn if role_arn is not None else ''
  723        self.role_external_id = role_external_id if role_external_id is not None else ''
  724        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
  725        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  726        '''
  727         ID of the secret store containing credentials for this resource, if any.
  728        '''
  729        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  730        '''
  731         Tags is a map of key, value pairs.
  732        '''
  733
  734    def __repr__(self):
  735        return '<sdm.AWS ' + \
  736            'access_key: ' + repr(self.access_key) + ' ' +\
  737            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  738            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  739            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
  740            'healthy: ' + repr(self.healthy) + ' ' +\
  741            'id: ' + repr(self.id) + ' ' +\
  742            'name: ' + repr(self.name) + ' ' +\
  743            'role_arn: ' + repr(self.role_arn) + ' ' +\
  744            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
  745            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
  746            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  747            'tags: ' + repr(self.tags) + ' ' +\
  748            '>'
  749
  750    def to_dict(self):
  751        return {
  752            'access_key': self.access_key,
  753            'bind_interface': self.bind_interface,
  754            'egress_filter': self.egress_filter,
  755            'healthcheck_region': self.healthcheck_region,
  756            'healthy': self.healthy,
  757            'id': self.id,
  758            'name': self.name,
  759            'role_arn': self.role_arn,
  760            'role_external_id': self.role_external_id,
  761            'secret_access_key': self.secret_access_key,
  762            'secret_store_id': self.secret_store_id,
  763            'tags': self.tags,
  764        }
  765
  766    @classmethod
  767    def from_dict(cls, d):
  768        return cls(
  769            access_key=d.get('access_key'),
  770            bind_interface=d.get('bind_interface'),
  771            egress_filter=d.get('egress_filter'),
  772            healthcheck_region=d.get('healthcheck_region'),
  773            healthy=d.get('healthy'),
  774            id=d.get('id'),
  775            name=d.get('name'),
  776            role_arn=d.get('role_arn'),
  777            role_external_id=d.get('role_external_id'),
  778            secret_access_key=d.get('secret_access_key'),
  779            secret_store_id=d.get('secret_store_id'),
  780            tags=d.get('tags'),
  781        )
  782
  783
  784class AWSConsole:
  785    '''
  786    AWSConsole is currently unstable, and its API may change, or it may be removed,
  787    without a major version bump.
  788    '''
  789    __slots__ = [
  790        'bind_interface',
  791        'egress_filter',
  792        'enable_env_variables',
  793        'healthy',
  794        'id',
  795        'name',
  796        'port_override',
  797        'region',
  798        'remote_identity_group_id',
  799        'remote_identity_healthcheck_username',
  800        'role_arn',
  801        'role_external_id',
  802        'secret_store_id',
  803        'session_expiry',
  804        'subdomain',
  805        'tags',
  806    ]
  807
  808    def __init__(
  809        self,
  810        bind_interface=None,
  811        egress_filter=None,
  812        enable_env_variables=None,
  813        healthy=None,
  814        id=None,
  815        name=None,
  816        port_override=None,
  817        region=None,
  818        remote_identity_group_id=None,
  819        remote_identity_healthcheck_username=None,
  820        role_arn=None,
  821        role_external_id=None,
  822        secret_store_id=None,
  823        session_expiry=None,
  824        subdomain=None,
  825        tags=None,
  826    ):
  827        self.bind_interface = bind_interface if bind_interface is not None else ''
  828        '''
  829         Bind interface
  830        '''
  831        self.egress_filter = egress_filter if egress_filter is not None else ''
  832        '''
  833         A filter applied to the routing logic to pin datasource to nodes.
  834        '''
  835        self.enable_env_variables = enable_env_variables if enable_env_variables is not None else False
  836        self.healthy = healthy if healthy is not None else False
  837        '''
  838         True if the datasource is reachable and the credentials are valid.
  839        '''
  840        self.id = id if id is not None else ''
  841        '''
  842         Unique identifier of the Resource.
  843        '''
  844        self.name = name if name is not None else ''
  845        '''
  846         Unique human-readable name of the Resource.
  847        '''
  848        self.port_override = port_override if port_override is not None else 0
  849        self.region = region if region is not None else ''
  850        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  851        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  852        self.role_arn = role_arn if role_arn is not None else ''
  853        self.role_external_id = role_external_id if role_external_id is not None else ''
  854        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  855        '''
  856         ID of the secret store containing credentials for this resource, if any.
  857        '''
  858        self.session_expiry = session_expiry if session_expiry is not None else 0
  859        self.subdomain = subdomain if subdomain is not None else ''
  860        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  861        '''
  862         Tags is a map of key, value pairs.
  863        '''
  864
  865    def __repr__(self):
  866        return '<sdm.AWSConsole ' + \
  867            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  868            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  869            'enable_env_variables: ' + repr(self.enable_env_variables) + ' ' +\
  870            'healthy: ' + repr(self.healthy) + ' ' +\
  871            'id: ' + repr(self.id) + ' ' +\
  872            'name: ' + repr(self.name) + ' ' +\
  873            'port_override: ' + repr(self.port_override) + ' ' +\
  874            'region: ' + repr(self.region) + ' ' +\
  875            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  876            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  877            'role_arn: ' + repr(self.role_arn) + ' ' +\
  878            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
  879            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  880            'session_expiry: ' + repr(self.session_expiry) + ' ' +\
  881            'subdomain: ' + repr(self.subdomain) + ' ' +\
  882            'tags: ' + repr(self.tags) + ' ' +\
  883            '>'
  884
  885    def to_dict(self):
  886        return {
  887            'bind_interface': self.bind_interface,
  888            'egress_filter': self.egress_filter,
  889            'enable_env_variables': self.enable_env_variables,
  890            'healthy': self.healthy,
  891            'id': self.id,
  892            'name': self.name,
  893            'port_override': self.port_override,
  894            'region': self.region,
  895            'remote_identity_group_id': self.remote_identity_group_id,
  896            'remote_identity_healthcheck_username':
  897            self.remote_identity_healthcheck_username,
  898            'role_arn': self.role_arn,
  899            'role_external_id': self.role_external_id,
  900            'secret_store_id': self.secret_store_id,
  901            'session_expiry': self.session_expiry,
  902            'subdomain': self.subdomain,
  903            'tags': self.tags,
  904        }
  905
  906    @classmethod
  907    def from_dict(cls, d):
  908        return cls(
  909            bind_interface=d.get('bind_interface'),
  910            egress_filter=d.get('egress_filter'),
  911            enable_env_variables=d.get('enable_env_variables'),
  912            healthy=d.get('healthy'),
  913            id=d.get('id'),
  914            name=d.get('name'),
  915            port_override=d.get('port_override'),
  916            region=d.get('region'),
  917            remote_identity_group_id=d.get('remote_identity_group_id'),
  918            remote_identity_healthcheck_username=d.get(
  919                'remote_identity_healthcheck_username'),
  920            role_arn=d.get('role_arn'),
  921            role_external_id=d.get('role_external_id'),
  922            secret_store_id=d.get('secret_store_id'),
  923            session_expiry=d.get('session_expiry'),
  924            subdomain=d.get('subdomain'),
  925            tags=d.get('tags'),
  926        )
  927
  928
  929class AWSConsoleStaticKeyPair:
  930    '''
  931    AWSConsoleStaticKeyPair is currently unstable, and its API may change, or it may be removed,
  932    without a major version bump.
  933    '''
  934    __slots__ = [
  935        'access_key',
  936        'bind_interface',
  937        'egress_filter',
  938        'healthy',
  939        'id',
  940        'name',
  941        'port_override',
  942        'region',
  943        'remote_identity_group_id',
  944        'remote_identity_healthcheck_username',
  945        'role_arn',
  946        'role_external_id',
  947        'secret_access_key',
  948        'secret_store_id',
  949        'session_expiry',
  950        'subdomain',
  951        'tags',
  952    ]
  953
  954    def __init__(
  955        self,
  956        access_key=None,
  957        bind_interface=None,
  958        egress_filter=None,
  959        healthy=None,
  960        id=None,
  961        name=None,
  962        port_override=None,
  963        region=None,
  964        remote_identity_group_id=None,
  965        remote_identity_healthcheck_username=None,
  966        role_arn=None,
  967        role_external_id=None,
  968        secret_access_key=None,
  969        secret_store_id=None,
  970        session_expiry=None,
  971        subdomain=None,
  972        tags=None,
  973    ):
  974        self.access_key = access_key if access_key is not None else ''
  975        self.bind_interface = bind_interface if bind_interface is not None else ''
  976        '''
  977         Bind interface
  978        '''
  979        self.egress_filter = egress_filter if egress_filter is not None else ''
  980        '''
  981         A filter applied to the routing logic to pin datasource to nodes.
  982        '''
  983        self.healthy = healthy if healthy is not None else False
  984        '''
  985         True if the datasource is reachable and the credentials are valid.
  986        '''
  987        self.id = id if id is not None else ''
  988        '''
  989         Unique identifier of the Resource.
  990        '''
  991        self.name = name if name is not None else ''
  992        '''
  993         Unique human-readable name of the Resource.
  994        '''
  995        self.port_override = port_override if port_override is not None else 0
  996        self.region = region if region is not None else ''
  997        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  998        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  999        self.role_arn = role_arn if role_arn is not None else ''
 1000        self.role_external_id = role_external_id if role_external_id is not None else ''
 1001        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1002        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1003        '''
 1004         ID of the secret store containing credentials for this resource, if any.
 1005        '''
 1006        self.session_expiry = session_expiry if session_expiry is not None else 0
 1007        self.subdomain = subdomain if subdomain is not None else ''
 1008        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1009        '''
 1010         Tags is a map of key, value pairs.
 1011        '''
 1012
 1013    def __repr__(self):
 1014        return '<sdm.AWSConsoleStaticKeyPair ' + \
 1015            'access_key: ' + repr(self.access_key) + ' ' +\
 1016            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1017            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1018            'healthy: ' + repr(self.healthy) + ' ' +\
 1019            'id: ' + repr(self.id) + ' ' +\
 1020            'name: ' + repr(self.name) + ' ' +\
 1021            'port_override: ' + repr(self.port_override) + ' ' +\
 1022            'region: ' + repr(self.region) + ' ' +\
 1023            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 1024            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 1025            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1026            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1027            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1028            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1029            'session_expiry: ' + repr(self.session_expiry) + ' ' +\
 1030            'subdomain: ' + repr(self.subdomain) + ' ' +\
 1031            'tags: ' + repr(self.tags) + ' ' +\
 1032            '>'
 1033
 1034    def to_dict(self):
 1035        return {
 1036            'access_key': self.access_key,
 1037            'bind_interface': self.bind_interface,
 1038            'egress_filter': self.egress_filter,
 1039            'healthy': self.healthy,
 1040            'id': self.id,
 1041            'name': self.name,
 1042            'port_override': self.port_override,
 1043            'region': self.region,
 1044            'remote_identity_group_id': self.remote_identity_group_id,
 1045            'remote_identity_healthcheck_username':
 1046            self.remote_identity_healthcheck_username,
 1047            'role_arn': self.role_arn,
 1048            'role_external_id': self.role_external_id,
 1049            'secret_access_key': self.secret_access_key,
 1050            'secret_store_id': self.secret_store_id,
 1051            'session_expiry': self.session_expiry,
 1052            'subdomain': self.subdomain,
 1053            'tags': self.tags,
 1054        }
 1055
 1056    @classmethod
 1057    def from_dict(cls, d):
 1058        return cls(
 1059            access_key=d.get('access_key'),
 1060            bind_interface=d.get('bind_interface'),
 1061            egress_filter=d.get('egress_filter'),
 1062            healthy=d.get('healthy'),
 1063            id=d.get('id'),
 1064            name=d.get('name'),
 1065            port_override=d.get('port_override'),
 1066            region=d.get('region'),
 1067            remote_identity_group_id=d.get('remote_identity_group_id'),
 1068            remote_identity_healthcheck_username=d.get(
 1069                'remote_identity_healthcheck_username'),
 1070            role_arn=d.get('role_arn'),
 1071            role_external_id=d.get('role_external_id'),
 1072            secret_access_key=d.get('secret_access_key'),
 1073            secret_store_id=d.get('secret_store_id'),
 1074            session_expiry=d.get('session_expiry'),
 1075            subdomain=d.get('subdomain'),
 1076            tags=d.get('tags'),
 1077        )
 1078
 1079
 1080class AWSStore:
 1081    __slots__ = [
 1082        'id',
 1083        'name',
 1084        'region',
 1085        'tags',
 1086    ]
 1087
 1088    def __init__(
 1089        self,
 1090        id=None,
 1091        name=None,
 1092        region=None,
 1093        tags=None,
 1094    ):
 1095        self.id = id if id is not None else ''
 1096        '''
 1097         Unique identifier of the SecretStore.
 1098        '''
 1099        self.name = name if name is not None else ''
 1100        '''
 1101         Unique human-readable name of the SecretStore.
 1102        '''
 1103        self.region = region if region is not None else ''
 1104        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1105        '''
 1106         Tags is a map of key, value pairs.
 1107        '''
 1108
 1109    def __repr__(self):
 1110        return '<sdm.AWSStore ' + \
 1111            'id: ' + repr(self.id) + ' ' +\
 1112            'name: ' + repr(self.name) + ' ' +\
 1113            'region: ' + repr(self.region) + ' ' +\
 1114            'tags: ' + repr(self.tags) + ' ' +\
 1115            '>'
 1116
 1117    def to_dict(self):
 1118        return {
 1119            'id': self.id,
 1120            'name': self.name,
 1121            'region': self.region,
 1122            'tags': self.tags,
 1123        }
 1124
 1125    @classmethod
 1126    def from_dict(cls, d):
 1127        return cls(
 1128            id=d.get('id'),
 1129            name=d.get('name'),
 1130            region=d.get('region'),
 1131            tags=d.get('tags'),
 1132        )
 1133
 1134
 1135class AccountAttachment:
 1136    '''
 1137         AccountAttachments assign an account to a role.
 1138    '''
 1139    __slots__ = [
 1140        'account_id',
 1141        'id',
 1142        'role_id',
 1143    ]
 1144
 1145    def __init__(
 1146        self,
 1147        account_id=None,
 1148        id=None,
 1149        role_id=None,
 1150    ):
 1151        self.account_id = account_id if account_id is not None else ''
 1152        '''
 1153         The id of the account of this AccountAttachment.
 1154        '''
 1155        self.id = id if id is not None else ''
 1156        '''
 1157         Unique identifier of the AccountAttachment.
 1158        '''
 1159        self.role_id = role_id if role_id is not None else ''
 1160        '''
 1161         The id of the attached role of this AccountAttachment.
 1162        '''
 1163
 1164    def __repr__(self):
 1165        return '<sdm.AccountAttachment ' + \
 1166            'account_id: ' + repr(self.account_id) + ' ' +\
 1167            'id: ' + repr(self.id) + ' ' +\
 1168            'role_id: ' + repr(self.role_id) + ' ' +\
 1169            '>'
 1170
 1171    def to_dict(self):
 1172        return {
 1173            'account_id': self.account_id,
 1174            'id': self.id,
 1175            'role_id': self.role_id,
 1176        }
 1177
 1178    @classmethod
 1179    def from_dict(cls, d):
 1180        return cls(
 1181            account_id=d.get('account_id'),
 1182            id=d.get('id'),
 1183            role_id=d.get('role_id'),
 1184        )
 1185
 1186
 1187class AccountAttachmentCreateResponse:
 1188    '''
 1189         AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
 1190    '''
 1191    __slots__ = [
 1192        'account_attachment',
 1193        'meta',
 1194        'rate_limit',
 1195    ]
 1196
 1197    def __init__(
 1198        self,
 1199        account_attachment=None,
 1200        meta=None,
 1201        rate_limit=None,
 1202    ):
 1203        self.account_attachment = account_attachment if account_attachment is not None else None
 1204        '''
 1205         The created AccountAttachment.
 1206        '''
 1207        self.meta = meta if meta is not None else None
 1208        '''
 1209         Reserved for future use.
 1210        '''
 1211        self.rate_limit = rate_limit if rate_limit is not None else None
 1212        '''
 1213         Rate limit information.
 1214        '''
 1215
 1216    def __repr__(self):
 1217        return '<sdm.AccountAttachmentCreateResponse ' + \
 1218            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1219            'meta: ' + repr(self.meta) + ' ' +\
 1220            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1221            '>'
 1222
 1223    def to_dict(self):
 1224        return {
 1225            'account_attachment': self.account_attachment,
 1226            'meta': self.meta,
 1227            'rate_limit': self.rate_limit,
 1228        }
 1229
 1230    @classmethod
 1231    def from_dict(cls, d):
 1232        return cls(
 1233            account_attachment=d.get('account_attachment'),
 1234            meta=d.get('meta'),
 1235            rate_limit=d.get('rate_limit'),
 1236        )
 1237
 1238
 1239class AccountAttachmentDeleteResponse:
 1240    '''
 1241         AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
 1242    '''
 1243    __slots__ = [
 1244        'meta',
 1245        'rate_limit',
 1246    ]
 1247
 1248    def __init__(
 1249        self,
 1250        meta=None,
 1251        rate_limit=None,
 1252    ):
 1253        self.meta = meta if meta is not None else None
 1254        '''
 1255         Reserved for future use.
 1256        '''
 1257        self.rate_limit = rate_limit if rate_limit is not None else None
 1258        '''
 1259         Rate limit information.
 1260        '''
 1261
 1262    def __repr__(self):
 1263        return '<sdm.AccountAttachmentDeleteResponse ' + \
 1264            'meta: ' + repr(self.meta) + ' ' +\
 1265            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1266            '>'
 1267
 1268    def to_dict(self):
 1269        return {
 1270            'meta': self.meta,
 1271            'rate_limit': self.rate_limit,
 1272        }
 1273
 1274    @classmethod
 1275    def from_dict(cls, d):
 1276        return cls(
 1277            meta=d.get('meta'),
 1278            rate_limit=d.get('rate_limit'),
 1279        )
 1280
 1281
 1282class AccountAttachmentGetResponse:
 1283    '''
 1284         AccountAttachmentGetResponse returns a requested AccountAttachment.
 1285    '''
 1286    __slots__ = [
 1287        'account_attachment',
 1288        'meta',
 1289        'rate_limit',
 1290    ]
 1291
 1292    def __init__(
 1293        self,
 1294        account_attachment=None,
 1295        meta=None,
 1296        rate_limit=None,
 1297    ):
 1298        self.account_attachment = account_attachment if account_attachment is not None else None
 1299        '''
 1300         The requested AccountAttachment.
 1301        '''
 1302        self.meta = meta if meta is not None else None
 1303        '''
 1304         Reserved for future use.
 1305        '''
 1306        self.rate_limit = rate_limit if rate_limit is not None else None
 1307        '''
 1308         Rate limit information.
 1309        '''
 1310
 1311    def __repr__(self):
 1312        return '<sdm.AccountAttachmentGetResponse ' + \
 1313            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1314            'meta: ' + repr(self.meta) + ' ' +\
 1315            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1316            '>'
 1317
 1318    def to_dict(self):
 1319        return {
 1320            'account_attachment': self.account_attachment,
 1321            'meta': self.meta,
 1322            'rate_limit': self.rate_limit,
 1323        }
 1324
 1325    @classmethod
 1326    def from_dict(cls, d):
 1327        return cls(
 1328            account_attachment=d.get('account_attachment'),
 1329            meta=d.get('meta'),
 1330            rate_limit=d.get('rate_limit'),
 1331        )
 1332
 1333
 1334class AccountCreateResponse:
 1335    '''
 1336         AccountCreateResponse reports how the Accounts were created in the system.
 1337    '''
 1338    __slots__ = [
 1339        'account',
 1340        'meta',
 1341        'rate_limit',
 1342        'token',
 1343    ]
 1344
 1345    def __init__(
 1346        self,
 1347        account=None,
 1348        meta=None,
 1349        rate_limit=None,
 1350        token=None,
 1351    ):
 1352        self.account = account if account is not None else None
 1353        '''
 1354         The created Account.
 1355        '''
 1356        self.meta = meta if meta is not None else None
 1357        '''
 1358         Reserved for future use.
 1359        '''
 1360        self.rate_limit = rate_limit if rate_limit is not None else None
 1361        '''
 1362         Rate limit information.
 1363        '''
 1364        self.token = token if token is not None else ''
 1365        '''
 1366         The auth token generated for the Account. The Account will use this token to
 1367         authenticate with the strongDM API.
 1368        '''
 1369
 1370    def __repr__(self):
 1371        return '<sdm.AccountCreateResponse ' + \
 1372            'account: ' + repr(self.account) + ' ' +\
 1373            'meta: ' + repr(self.meta) + ' ' +\
 1374            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1375            'token: ' + repr(self.token) + ' ' +\
 1376            '>'
 1377
 1378    def to_dict(self):
 1379        return {
 1380            'account': self.account,
 1381            'meta': self.meta,
 1382            'rate_limit': self.rate_limit,
 1383            'token': self.token,
 1384        }
 1385
 1386    @classmethod
 1387    def from_dict(cls, d):
 1388        return cls(
 1389            account=d.get('account'),
 1390            meta=d.get('meta'),
 1391            rate_limit=d.get('rate_limit'),
 1392            token=d.get('token'),
 1393        )
 1394
 1395
 1396class AccountDeleteResponse:
 1397    '''
 1398         AccountDeleteResponse returns information about a Account that was deleted.
 1399    '''
 1400    __slots__ = [
 1401        'meta',
 1402        'rate_limit',
 1403    ]
 1404
 1405    def __init__(
 1406        self,
 1407        meta=None,
 1408        rate_limit=None,
 1409    ):
 1410        self.meta = meta if meta is not None else None
 1411        '''
 1412         Reserved for future use.
 1413        '''
 1414        self.rate_limit = rate_limit if rate_limit is not None else None
 1415        '''
 1416         Rate limit information.
 1417        '''
 1418
 1419    def __repr__(self):
 1420        return '<sdm.AccountDeleteResponse ' + \
 1421            'meta: ' + repr(self.meta) + ' ' +\
 1422            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1423            '>'
 1424
 1425    def to_dict(self):
 1426        return {
 1427            'meta': self.meta,
 1428            'rate_limit': self.rate_limit,
 1429        }
 1430
 1431    @classmethod
 1432    def from_dict(cls, d):
 1433        return cls(
 1434            meta=d.get('meta'),
 1435            rate_limit=d.get('rate_limit'),
 1436        )
 1437
 1438
 1439class AccountGetResponse:
 1440    '''
 1441         AccountGetResponse returns a requested Account.
 1442    '''
 1443    __slots__ = [
 1444        'account',
 1445        'meta',
 1446        'rate_limit',
 1447    ]
 1448
 1449    def __init__(
 1450        self,
 1451        account=None,
 1452        meta=None,
 1453        rate_limit=None,
 1454    ):
 1455        self.account = account if account is not None else None
 1456        '''
 1457         The requested Account.
 1458        '''
 1459        self.meta = meta if meta is not None else None
 1460        '''
 1461         Reserved for future use.
 1462        '''
 1463        self.rate_limit = rate_limit if rate_limit is not None else None
 1464        '''
 1465         Rate limit information.
 1466        '''
 1467
 1468    def __repr__(self):
 1469        return '<sdm.AccountGetResponse ' + \
 1470            'account: ' + repr(self.account) + ' ' +\
 1471            'meta: ' + repr(self.meta) + ' ' +\
 1472            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1473            '>'
 1474
 1475    def to_dict(self):
 1476        return {
 1477            'account': self.account,
 1478            'meta': self.meta,
 1479            'rate_limit': self.rate_limit,
 1480        }
 1481
 1482    @classmethod
 1483    def from_dict(cls, d):
 1484        return cls(
 1485            account=d.get('account'),
 1486            meta=d.get('meta'),
 1487            rate_limit=d.get('rate_limit'),
 1488        )
 1489
 1490
 1491class AccountGrant:
 1492    '''
 1493         AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
 1494    '''
 1495    __slots__ = [
 1496        'account_id',
 1497        'id',
 1498        'resource_id',
 1499        'start_from',
 1500        'valid_until',
 1501    ]
 1502
 1503    def __init__(
 1504        self,
 1505        account_id=None,
 1506        id=None,
 1507        resource_id=None,
 1508        start_from=None,
 1509        valid_until=None,
 1510    ):
 1511        self.account_id = account_id if account_id is not None else ''
 1512        '''
 1513         The account ID of this AccountGrant.
 1514        '''
 1515        self.id = id if id is not None else ''
 1516        '''
 1517         Unique identifier of the AccountGrant.
 1518        '''
 1519        self.resource_id = resource_id if resource_id is not None else ''
 1520        '''
 1521         The resource ID of this AccountGrant.
 1522        '''
 1523        self.start_from = start_from if start_from is not None else None
 1524        '''
 1525         The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.
 1526        '''
 1527        self.valid_until = valid_until if valid_until is not None else None
 1528        '''
 1529         The timestamp when the resource grant will expire.
 1530        '''
 1531
 1532    def __repr__(self):
 1533        return '<sdm.AccountGrant ' + \
 1534            'account_id: ' + repr(self.account_id) + ' ' +\
 1535            'id: ' + repr(self.id) + ' ' +\
 1536            'resource_id: ' + repr(self.resource_id) + ' ' +\
 1537            'start_from: ' + repr(self.start_from) + ' ' +\
 1538            'valid_until: ' + repr(self.valid_until) + ' ' +\
 1539            '>'
 1540
 1541    def to_dict(self):
 1542        return {
 1543            'account_id': self.account_id,
 1544            'id': self.id,
 1545            'resource_id': self.resource_id,
 1546            'start_from': self.start_from,
 1547            'valid_until': self.valid_until,
 1548        }
 1549
 1550    @classmethod
 1551    def from_dict(cls, d):
 1552        return cls(
 1553            account_id=d.get('account_id'),
 1554            id=d.get('id'),
 1555            resource_id=d.get('resource_id'),
 1556            start_from=d.get('start_from'),
 1557            valid_until=d.get('valid_until'),
 1558        )
 1559
 1560
 1561class AccountGrantCreateResponse:
 1562    '''
 1563         AccountGrantCreateResponse reports how the AccountGrants were created in the system.
 1564    '''
 1565    __slots__ = [
 1566        'account_grant',
 1567        'meta',
 1568        'rate_limit',
 1569    ]
 1570
 1571    def __init__(
 1572        self,
 1573        account_grant=None,
 1574        meta=None,
 1575        rate_limit=None,
 1576    ):
 1577        self.account_grant = account_grant if account_grant is not None else None
 1578        '''
 1579         The created AccountGrant.
 1580        '''
 1581        self.meta = meta if meta is not None else None
 1582        '''
 1583         Reserved for future use.
 1584        '''
 1585        self.rate_limit = rate_limit if rate_limit is not None else None
 1586        '''
 1587         Rate limit information.
 1588        '''
 1589
 1590    def __repr__(self):
 1591        return '<sdm.AccountGrantCreateResponse ' + \
 1592            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1593            'meta: ' + repr(self.meta) + ' ' +\
 1594            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1595            '>'
 1596
 1597    def to_dict(self):
 1598        return {
 1599            'account_grant': self.account_grant,
 1600            'meta': self.meta,
 1601            'rate_limit': self.rate_limit,
 1602        }
 1603
 1604    @classmethod
 1605    def from_dict(cls, d):
 1606        return cls(
 1607            account_grant=d.get('account_grant'),
 1608            meta=d.get('meta'),
 1609            rate_limit=d.get('rate_limit'),
 1610        )
 1611
 1612
 1613class AccountGrantDeleteResponse:
 1614    '''
 1615         AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
 1616    '''
 1617    __slots__ = [
 1618        'meta',
 1619        'rate_limit',
 1620    ]
 1621
 1622    def __init__(
 1623        self,
 1624        meta=None,
 1625        rate_limit=None,
 1626    ):
 1627        self.meta = meta if meta is not None else None
 1628        '''
 1629         Reserved for future use.
 1630        '''
 1631        self.rate_limit = rate_limit if rate_limit is not None else None
 1632        '''
 1633         Rate limit information.
 1634        '''
 1635
 1636    def __repr__(self):
 1637        return '<sdm.AccountGrantDeleteResponse ' + \
 1638            'meta: ' + repr(self.meta) + ' ' +\
 1639            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1640            '>'
 1641
 1642    def to_dict(self):
 1643        return {
 1644            'meta': self.meta,
 1645            'rate_limit': self.rate_limit,
 1646        }
 1647
 1648    @classmethod
 1649    def from_dict(cls, d):
 1650        return cls(
 1651            meta=d.get('meta'),
 1652            rate_limit=d.get('rate_limit'),
 1653        )
 1654
 1655
 1656class AccountGrantGetResponse:
 1657    '''
 1658         AccountGrantGetResponse returns a requested AccountGrant.
 1659    '''
 1660    __slots__ = [
 1661        'account_grant',
 1662        'meta',
 1663        'rate_limit',
 1664    ]
 1665
 1666    def __init__(
 1667        self,
 1668        account_grant=None,
 1669        meta=None,
 1670        rate_limit=None,
 1671    ):
 1672        self.account_grant = account_grant if account_grant is not None else None
 1673        '''
 1674         The requested AccountGrant.
 1675        '''
 1676        self.meta = meta if meta is not None else None
 1677        '''
 1678         Reserved for future use.
 1679        '''
 1680        self.rate_limit = rate_limit if rate_limit is not None else None
 1681        '''
 1682         Rate limit information.
 1683        '''
 1684
 1685    def __repr__(self):
 1686        return '<sdm.AccountGrantGetResponse ' + \
 1687            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1688            'meta: ' + repr(self.meta) + ' ' +\
 1689            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1690            '>'
 1691
 1692    def to_dict(self):
 1693        return {
 1694            'account_grant': self.account_grant,
 1695            'meta': self.meta,
 1696            'rate_limit': self.rate_limit,
 1697        }
 1698
 1699    @classmethod
 1700    def from_dict(cls, d):
 1701        return cls(
 1702            account_grant=d.get('account_grant'),
 1703            meta=d.get('meta'),
 1704            rate_limit=d.get('rate_limit'),
 1705        )
 1706
 1707
 1708class AccountUpdateResponse:
 1709    '''
 1710         AccountUpdateResponse returns the fields of a Account after it has been updated by
 1711     a AccountUpdateRequest.
 1712    '''
 1713    __slots__ = [
 1714        'account',
 1715        'meta',
 1716        'rate_limit',
 1717    ]
 1718
 1719    def __init__(
 1720        self,
 1721        account=None,
 1722        meta=None,
 1723        rate_limit=None,
 1724    ):
 1725        self.account = account if account is not None else None
 1726        '''
 1727         The updated Account.
 1728        '''
 1729        self.meta = meta if meta is not None else None
 1730        '''
 1731         Reserved for future use.
 1732        '''
 1733        self.rate_limit = rate_limit if rate_limit is not None else None
 1734        '''
 1735         Rate limit information.
 1736        '''
 1737
 1738    def __repr__(self):
 1739        return '<sdm.AccountUpdateResponse ' + \
 1740            'account: ' + repr(self.account) + ' ' +\
 1741            'meta: ' + repr(self.meta) + ' ' +\
 1742            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1743            '>'
 1744
 1745    def to_dict(self):
 1746        return {
 1747            'account': self.account,
 1748            'meta': self.meta,
 1749            'rate_limit': self.rate_limit,
 1750        }
 1751
 1752    @classmethod
 1753    def from_dict(cls, d):
 1754        return cls(
 1755            account=d.get('account'),
 1756            meta=d.get('meta'),
 1757            rate_limit=d.get('rate_limit'),
 1758        )
 1759
 1760
 1761class AmazonEKS:
 1762    __slots__ = [
 1763        'access_key',
 1764        'bind_interface',
 1765        'certificate_authority',
 1766        'cluster_name',
 1767        'egress_filter',
 1768        'endpoint',
 1769        'healthcheck_namespace',
 1770        'healthy',
 1771        'id',
 1772        'name',
 1773        'region',
 1774        'remote_identity_group_id',
 1775        'remote_identity_healthcheck_username',
 1776        'role_arn',
 1777        'role_external_id',
 1778        'secret_access_key',
 1779        'secret_store_id',
 1780        'tags',
 1781    ]
 1782
 1783    def __init__(
 1784        self,
 1785        access_key=None,
 1786        bind_interface=None,
 1787        certificate_authority=None,
 1788        cluster_name=None,
 1789        egress_filter=None,
 1790        endpoint=None,
 1791        healthcheck_namespace=None,
 1792        healthy=None,
 1793        id=None,
 1794        name=None,
 1795        region=None,
 1796        remote_identity_group_id=None,
 1797        remote_identity_healthcheck_username=None,
 1798        role_arn=None,
 1799        role_external_id=None,
 1800        secret_access_key=None,
 1801        secret_store_id=None,
 1802        tags=None,
 1803    ):
 1804        self.access_key = access_key if access_key is not None else ''
 1805        self.bind_interface = bind_interface if bind_interface is not None else ''
 1806        '''
 1807         Bind interface
 1808        '''
 1809        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1810        self.cluster_name = cluster_name if cluster_name is not None else ''
 1811        self.egress_filter = egress_filter if egress_filter is not None else ''
 1812        '''
 1813         A filter applied to the routing logic to pin datasource to nodes.
 1814        '''
 1815        self.endpoint = endpoint if endpoint is not None else ''
 1816        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1817        '''
 1818         The path used to check the health of your connection.  Defaults to `default`.
 1819        '''
 1820        self.healthy = healthy if healthy is not None else False
 1821        '''
 1822         True if the datasource is reachable and the credentials are valid.
 1823        '''
 1824        self.id = id if id is not None else ''
 1825        '''
 1826         Unique identifier of the Resource.
 1827        '''
 1828        self.name = name if name is not None else ''
 1829        '''
 1830         Unique human-readable name of the Resource.
 1831        '''
 1832        self.region = region if region is not None else ''
 1833        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 1834        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 1835        self.role_arn = role_arn if role_arn is not None else ''
 1836        self.role_external_id = role_external_id if role_external_id is not None else ''
 1837        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1838        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1839        '''
 1840         ID of the secret store containing credentials for this resource, if any.
 1841        '''
 1842        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1843        '''
 1844         Tags is a map of key, value pairs.
 1845        '''
 1846
 1847    def __repr__(self):
 1848        return '<sdm.AmazonEKS ' + \
 1849            'access_key: ' + repr(self.access_key) + ' ' +\
 1850            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1851            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 1852            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 1853            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1854            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1855            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 1856            'healthy: ' + repr(self.healthy) + ' ' +\
 1857            'id: ' + repr(self.id) + ' ' +\
 1858            'name: ' + repr(self.name) + ' ' +\
 1859            'region: ' + repr(self.region) + ' ' +\
 1860            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 1861            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 1862            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1863            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1864            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1865            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1866            'tags: ' + repr(self.tags) + ' ' +\
 1867            '>'
 1868
 1869    def to_dict(self):
 1870        return {
 1871            'access_key': self.access_key,
 1872            'bind_interface': self.bind_interface,
 1873            'certificate_authority': self.certificate_authority,
 1874            'cluster_name': self.cluster_name,
 1875            'egress_filter': self.egress_filter,
 1876            'endpoint': self.endpoint,
 1877            'healthcheck_namespace': self.healthcheck_namespace,
 1878            'healthy': self.healthy,
 1879            'id': self.id,
 1880            'name': self.name,
 1881            'region': self.region,
 1882            'remote_identity_group_id': self.remote_identity_group_id,
 1883            'remote_identity_healthcheck_username':
 1884            self.remote_identity_healthcheck_username,
 1885            'role_arn': self.role_arn,
 1886            'role_external_id': self.role_external_id,
 1887            'secret_access_key': self.secret_access_key,
 1888            'secret_store_id': self.secret_store_id,
 1889            'tags': self.tags,
 1890        }
 1891
 1892    @classmethod
 1893    def from_dict(cls, d):
 1894        return cls(
 1895            access_key=d.get('access_key'),
 1896            bind_interface=d.get('bind_interface'),
 1897            certificate_authority=d.get('certificate_authority'),
 1898            cluster_name=d.get('cluster_name'),
 1899            egress_filter=d.get('egress_filter'),
 1900            endpoint=d.get('endpoint'),
 1901            healthcheck_namespace=d.get('healthcheck_namespace'),
 1902            healthy=d.get('healthy'),
 1903            id=d.get('id'),
 1904            name=d.get('name'),
 1905            region=d.get('region'),
 1906            remote_identity_group_id=d.get('remote_identity_group_id'),
 1907            remote_identity_healthcheck_username=d.get(
 1908                'remote_identity_healthcheck_username'),
 1909            role_arn=d.get('role_arn'),
 1910            role_external_id=d.get('role_external_id'),
 1911            secret_access_key=d.get('secret_access_key'),
 1912            secret_store_id=d.get('secret_store_id'),
 1913            tags=d.get('tags'),
 1914        )
 1915
 1916
 1917class AmazonEKSUserImpersonation:
 1918    __slots__ = [
 1919        'access_key',
 1920        'bind_interface',
 1921        'certificate_authority',
 1922        'cluster_name',
 1923        'egress_filter',
 1924        'endpoint',
 1925        'healthcheck_namespace',
 1926        'healthy',
 1927        'id',
 1928        'name',
 1929        'region',
 1930        'role_arn',
 1931        'role_external_id',
 1932        'secret_access_key',
 1933        'secret_store_id',
 1934        'tags',
 1935    ]
 1936
 1937    def __init__(
 1938        self,
 1939        access_key=None,
 1940        bind_interface=None,
 1941        certificate_authority=None,
 1942        cluster_name=None,
 1943        egress_filter=None,
 1944        endpoint=None,
 1945        healthcheck_namespace=None,
 1946        healthy=None,
 1947        id=None,
 1948        name=None,
 1949        region=None,
 1950        role_arn=None,
 1951        role_external_id=None,
 1952        secret_access_key=None,
 1953        secret_store_id=None,
 1954        tags=None,
 1955    ):
 1956        self.access_key = access_key if access_key is not None else ''
 1957        self.bind_interface = bind_interface if bind_interface is not None else ''
 1958        '''
 1959         Bind interface
 1960        '''
 1961        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1962        self.cluster_name = cluster_name if cluster_name is not None else ''
 1963        self.egress_filter = egress_filter if egress_filter is not None else ''
 1964        '''
 1965         A filter applied to the routing logic to pin datasource to nodes.
 1966        '''
 1967        self.endpoint = endpoint if endpoint is not None else ''
 1968        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1969        '''
 1970         The path used to check the health of your connection.  Defaults to `default`.
 1971        '''
 1972        self.healthy = healthy if healthy is not None else False
 1973        '''
 1974         True if the datasource is reachable and the credentials are valid.
 1975        '''
 1976        self.id = id if id is not None else ''
 1977        '''
 1978         Unique identifier of the Resource.
 1979        '''
 1980        self.name = name if name is not None else ''
 1981        '''
 1982         Unique human-readable name of the Resource.
 1983        '''
 1984        self.region = region if region is not None else ''
 1985        self.role_arn = role_arn if role_arn is not None else ''
 1986        self.role_external_id = role_external_id if role_external_id is not None else ''
 1987        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1988        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1989        '''
 1990         ID of the secret store containing credentials for this resource, if any.
 1991        '''
 1992        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1993        '''
 1994         Tags is a map of key, value pairs.
 1995        '''
 1996
 1997    def __repr__(self):
 1998        return '<sdm.AmazonEKSUserImpersonation ' + \
 1999            'access_key: ' + repr(self.access_key) + ' ' +\
 2000            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2001            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 2002            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 2003            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2004            'endpoint: ' + repr(self.endpoint) + ' ' +\
 2005            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 2006            'healthy: ' + repr(self.healthy) + ' ' +\
 2007            'id: ' + repr(self.id) + ' ' +\
 2008            'name: ' + repr(self.name) + ' ' +\
 2009            'region: ' + repr(self.region) + ' ' +\
 2010            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2011            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2012            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2013            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2014            'tags: ' + repr(self.tags) + ' ' +\
 2015            '>'
 2016
 2017    def to_dict(self):
 2018        return {
 2019            'access_key': self.access_key,
 2020            'bind_interface': self.bind_interface,
 2021            'certificate_authority': self.certificate_authority,
 2022            'cluster_name': self.cluster_name,
 2023            'egress_filter': self.egress_filter,
 2024            'endpoint': self.endpoint,
 2025            'healthcheck_namespace': self.healthcheck_namespace,
 2026            'healthy': self.healthy,
 2027            'id': self.id,
 2028            'name': self.name,
 2029            'region': self.region,
 2030            'role_arn': self.role_arn,
 2031            'role_external_id': self.role_external_id,
 2032            'secret_access_key': self.secret_access_key,
 2033            'secret_store_id': self.secret_store_id,
 2034            'tags': self.tags,
 2035        }
 2036
 2037    @classmethod
 2038    def from_dict(cls, d):
 2039        return cls(
 2040            access_key=d.get('access_key'),
 2041            bind_interface=d.get('bind_interface'),
 2042            certificate_authority=d.get('certificate_authority'),
 2043            cluster_name=d.get('cluster_name'),
 2044            egress_filter=d.get('egress_filter'),
 2045            endpoint=d.get('endpoint'),
 2046            healthcheck_namespace=d.get('healthcheck_namespace'),
 2047            healthy=d.get('healthy'),
 2048            id=d.get('id'),
 2049            name=d.get('name'),
 2050            region=d.get('region'),
 2051            role_arn=d.get('role_arn'),
 2052            role_external_id=d.get('role_external_id'),
 2053            secret_access_key=d.get('secret_access_key'),
 2054            secret_store_id=d.get('secret_store_id'),
 2055            tags=d.get('tags'),
 2056        )
 2057
 2058
 2059class AmazonES:
 2060    __slots__ = [
 2061        'access_key',
 2062        'bind_interface',
 2063        'egress_filter',
 2064        'endpoint',
 2065        'healthy',
 2066        'id',
 2067        'name',
 2068        'port_override',
 2069        'region',
 2070        'role_arn',
 2071        'role_external_id',
 2072        'secret_access_key',
 2073        'secret_store_id',
 2074        'tags',
 2075    ]
 2076
 2077    def __init__(
 2078        self,
 2079        access_key=None,
 2080        bind_interface=None,
 2081        egress_filter=None,
 2082        endpoint=None,
 2083        healthy=None,
 2084        id=None,
 2085        name=None,
 2086        port_override=None,
 2087        region=None,
 2088        role_arn=None,
 2089        role_external_id=None,
 2090        secret_access_key=None,
 2091        secret_store_id=None,
 2092        tags=None,
 2093    ):
 2094        self.access_key = access_key if access_key is not None else ''
 2095        self.bind_interface = bind_interface if bind_interface is not None else ''
 2096        '''
 2097         Bind interface
 2098        '''
 2099        self.egress_filter = egress_filter if egress_filter is not None else ''
 2100        '''
 2101         A filter applied to the routing logic to pin datasource to nodes.
 2102        '''
 2103        self.endpoint = endpoint if endpoint is not None else ''
 2104        self.healthy = healthy if healthy is not None else False
 2105        '''
 2106         True if the datasource is reachable and the credentials are valid.
 2107        '''
 2108        self.id = id if id is not None else ''
 2109        '''
 2110         Unique identifier of the Resource.
 2111        '''
 2112        self.name = name if name is not None else ''
 2113        '''
 2114         Unique human-readable name of the Resource.
 2115        '''
 2116        self.port_override = port_override if port_override is not None else 0
 2117        self.region = region if region is not None else ''
 2118        self.role_arn = role_arn if role_arn is not None else ''
 2119        self.role_external_id = role_external_id if role_external_id is not None else ''
 2120        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2121        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2122        '''
 2123         ID of the secret store containing credentials for this resource, if any.
 2124        '''
 2125        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2126        '''
 2127         Tags is a map of key, value pairs.
 2128        '''
 2129
 2130    def __repr__(self):
 2131        return '<sdm.AmazonES ' + \
 2132            'access_key: ' + repr(self.access_key) + ' ' +\
 2133            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2134            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2135            'endpoint: ' + repr(self.endpoint) + ' ' +\
 2136            'healthy: ' + repr(self.healthy) + ' ' +\
 2137            'id: ' + repr(self.id) + ' ' +\
 2138            'name: ' + repr(self.name) + ' ' +\
 2139            'port_override: ' + repr(self.port_override) + ' ' +\
 2140            'region: ' + repr(self.region) + ' ' +\
 2141            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2142            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2143            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2144            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2145            'tags: ' + repr(self.tags) + ' ' +\
 2146            '>'
 2147
 2148    def to_dict(self):
 2149        return {
 2150            'access_key': self.access_key,
 2151            'bind_interface': self.bind_interface,
 2152            'egress_filter': self.egress_filter,
 2153            'endpoint': self.endpoint,
 2154            'healthy': self.healthy,
 2155            'id': self.id,
 2156            'name': self.name,
 2157            'port_override': self.port_override,
 2158            'region': self.region,
 2159            'role_arn': self.role_arn,
 2160            'role_external_id': self.role_external_id,
 2161            'secret_access_key': self.secret_access_key,
 2162            'secret_store_id': self.secret_store_id,
 2163            'tags': self.tags,
 2164        }
 2165
 2166    @classmethod
 2167    def from_dict(cls, d):
 2168        return cls(
 2169            access_key=d.get('access_key'),
 2170            bind_interface=d.get('bind_interface'),
 2171            egress_filter=d.get('egress_filter'),
 2172            endpoint=d.get('endpoint'),
 2173            healthy=d.get('healthy'),
 2174            id=d.get('id'),
 2175            name=d.get('name'),
 2176            port_override=d.get('port_override'),
 2177            region=d.get('region'),
 2178            role_arn=d.get('role_arn'),
 2179            role_external_id=d.get('role_external_id'),
 2180            secret_access_key=d.get('secret_access_key'),
 2181            secret_store_id=d.get('secret_store_id'),
 2182            tags=d.get('tags'),
 2183        )
 2184
 2185
 2186class AmazonMQAMQP091:
 2187    __slots__ = [
 2188        'bind_interface',
 2189        'egress_filter',
 2190        'healthy',
 2191        'hostname',
 2192        'id',
 2193        'name',
 2194        'password',
 2195        'port',
 2196        'port_override',
 2197        'secret_store_id',
 2198        'tags',
 2199        'tls_required',
 2200        'username',
 2201    ]
 2202
 2203    def __init__(
 2204        self,
 2205        bind_interface=None,
 2206        egress_filter=None,
 2207        healthy=None,
 2208        hostname=None,
 2209        id=None,
 2210        name=None,
 2211        password=None,
 2212        port=None,
 2213        port_override=None,
 2214        secret_store_id=None,
 2215        tags=None,
 2216        tls_required=None,
 2217        username=None,
 2218    ):
 2219        self.bind_interface = bind_interface if bind_interface is not None else ''
 2220        '''
 2221         Bind interface
 2222        '''
 2223        self.egress_filter = egress_filter if egress_filter is not None else ''
 2224        '''
 2225         A filter applied to the routing logic to pin datasource to nodes.
 2226        '''
 2227        self.healthy = healthy if healthy is not None else False
 2228        '''
 2229         True if the datasource is reachable and the credentials are valid.
 2230        '''
 2231        self.hostname = hostname if hostname is not None else ''
 2232        self.id = id if id is not None else ''
 2233        '''
 2234         Unique identifier of the Resource.
 2235        '''
 2236        self.name = name if name is not None else ''
 2237        '''
 2238         Unique human-readable name of the Resource.
 2239        '''
 2240        self.password = password if password is not None else ''
 2241        self.port = port if port is not None else 0
 2242        self.port_override = port_override if port_override is not None else 0
 2243        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2244        '''
 2245         ID of the secret store containing credentials for this resource, if any.
 2246        '''
 2247        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2248        '''
 2249         Tags is a map of key, value pairs.
 2250        '''
 2251        self.tls_required = tls_required if tls_required is not None else False
 2252        self.username = username if username is not None else ''
 2253
 2254    def __repr__(self):
 2255        return '<sdm.AmazonMQAMQP091 ' + \
 2256            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2257            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2258            'healthy: ' + repr(self.healthy) + ' ' +\
 2259            'hostname: ' + repr(self.hostname) + ' ' +\
 2260            'id: ' + repr(self.id) + ' ' +\
 2261            'name: ' + repr(self.name) + ' ' +\
 2262            'password: ' + repr(self.password) + ' ' +\
 2263            'port: ' + repr(self.port) + ' ' +\
 2264            'port_override: ' + repr(self.port_override) + ' ' +\
 2265            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2266            'tags: ' + repr(self.tags) + ' ' +\
 2267            'tls_required: ' + repr(self.tls_required) + ' ' +\
 2268            'username: ' + repr(self.username) + ' ' +\
 2269            '>'
 2270
 2271    def to_dict(self):
 2272        return {
 2273            'bind_interface': self.bind_interface,
 2274            'egress_filter': self.egress_filter,
 2275            'healthy': self.healthy,
 2276            'hostname': self.hostname,
 2277            'id': self.id,
 2278            'name': self.name,
 2279            'password': self.password,
 2280            'port': self.port,
 2281            'port_override': self.port_override,
 2282            'secret_store_id': self.secret_store_id,
 2283            'tags': self.tags,
 2284            'tls_required': self.tls_required,
 2285            'username': self.username,
 2286        }
 2287
 2288    @classmethod
 2289    def from_dict(cls, d):
 2290        return cls(
 2291            bind_interface=d.get('bind_interface'),
 2292            egress_filter=d.get('egress_filter'),
 2293            healthy=d.get('healthy'),
 2294            hostname=d.get('hostname'),
 2295            id=d.get('id'),
 2296            name=d.get('name'),
 2297            password=d.get('password'),
 2298            port=d.get('port'),
 2299            port_override=d.get('port_override'),
 2300            secret_store_id=d.get('secret_store_id'),
 2301            tags=d.get('tags'),
 2302            tls_required=d.get('tls_required'),
 2303            username=d.get('username'),
 2304        )
 2305
 2306
 2307class Athena:
 2308    __slots__ = [
 2309        'access_key',
 2310        'bind_interface',
 2311        'egress_filter',
 2312        'healthy',
 2313        'id',
 2314        'name',
 2315        'output',
 2316        'port_override',
 2317        'region',
 2318        'role_arn',
 2319        'role_external_id',
 2320        'secret_access_key',
 2321        'secret_store_id',
 2322        'tags',
 2323    ]
 2324
 2325    def __init__(
 2326        self,
 2327        access_key=None,
 2328        bind_interface=None,
 2329        egress_filter=None,
 2330        healthy=None,
 2331        id=None,
 2332        name=None,
 2333        output=None,
 2334        port_override=None,
 2335        region=None,
 2336        role_arn=None,
 2337        role_external_id=None,
 2338        secret_access_key=None,
 2339        secret_store_id=None,
 2340        tags=None,
 2341    ):
 2342        self.access_key = access_key if access_key is not None else ''
 2343        self.bind_interface = bind_interface if bind_interface is not None else ''
 2344        '''
 2345         Bind interface
 2346        '''
 2347        self.egress_filter = egress_filter if egress_filter is not None else ''
 2348        '''
 2349         A filter applied to the routing logic to pin datasource to nodes.
 2350        '''
 2351        self.healthy = healthy if healthy is not None else False
 2352        '''
 2353         True if the datasource is reachable and the credentials are valid.
 2354        '''
 2355        self.id = id if id is not None else ''
 2356        '''
 2357         Unique identifier of the Resource.
 2358        '''
 2359        self.name = name if name is not None else ''
 2360        '''
 2361         Unique human-readable name of the Resource.
 2362        '''
 2363        self.output = output if output is not None else ''
 2364        self.port_override = port_override if port_override is not None else 0
 2365        self.region = region if region is not None else ''
 2366        self.role_arn = role_arn if role_arn is not None else ''
 2367        self.role_external_id = role_external_id if role_external_id is not None else ''
 2368        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2369        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2370        '''
 2371         ID of the secret store containing credentials for this resource, if any.
 2372        '''
 2373        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2374        '''
 2375         Tags is a map of key, value pairs.
 2376        '''
 2377
 2378    def __repr__(self):
 2379        return '<sdm.Athena ' + \
 2380            'access_key: ' + repr(self.access_key) + ' ' +\
 2381            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2382            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2383            'healthy: ' + repr(self.healthy) + ' ' +\
 2384            'id: ' + repr(self.id) + ' ' +\
 2385            'name: ' + repr(self.name) + ' ' +\
 2386            'output: ' + repr(self.output) + ' ' +\
 2387            'port_override: ' + repr(self.port_override) + ' ' +\
 2388            'region: ' + repr(self.region) + ' ' +\
 2389            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2390            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2391            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2392            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2393            'tags: ' + repr(self.tags) + ' ' +\
 2394            '>'
 2395
 2396    def to_dict(self):
 2397        return {
 2398            'access_key': self.access_key,
 2399            'bind_interface': self.bind_interface,
 2400            'egress_filter': self.egress_filter,
 2401            'healthy': self.healthy,
 2402            'id': self.id,
 2403            'name': self.name,
 2404            'output': self.output,
 2405            'port_override': self.port_override,
 2406            'region': self.region,
 2407            'role_arn': self.role_arn,
 2408            'role_external_id': self.role_external_id,
 2409            'secret_access_key': self.secret_access_key,
 2410            'secret_store_id': self.secret_store_id,
 2411            'tags': self.tags,
 2412        }
 2413
 2414    @classmethod
 2415    def from_dict(cls, d):
 2416        return cls(
 2417            access_key=d.get('access_key'),
 2418            bind_interface=d.get('bind_interface'),
 2419            egress_filter=d.get('egress_filter'),
 2420            healthy=d.get('healthy'),
 2421            id=d.get('id'),
 2422            name=d.get('name'),
 2423            output=d.get('output'),
 2424            port_override=d.get('port_override'),
 2425            region=d.get('region'),
 2426            role_arn=d.get('role_arn'),
 2427            role_external_id=d.get('role_external_id'),
 2428            secret_access_key=d.get('secret_access_key'),
 2429            secret_store_id=d.get('secret_store_id'),
 2430            tags=d.get('tags'),
 2431        )
 2432
 2433
 2434class AuroraMysql:
 2435    __slots__ = [
 2436        'bind_interface',
 2437        'database',
 2438        'egress_filter',
 2439        'healthy',
 2440        'hostname',
 2441        'id',
 2442        'name',
 2443        'password',
 2444        'port',
 2445        'port_override',
 2446        'secret_store_id',
 2447        'tags',
 2448        'username',
 2449    ]
 2450
 2451    def __init__(
 2452        self,
 2453        bind_interface=None,
 2454        database=None,
 2455        egress_filter=None,
 2456        healthy=None,
 2457        hostname=None,
 2458        id=None,
 2459        name=None,
 2460        password=None,
 2461        port=None,
 2462        port_override=None,
 2463        secret_store_id=None,
 2464        tags=None,
 2465        username=None,
 2466    ):
 2467        self.bind_interface = bind_interface if bind_interface is not None else ''
 2468        '''
 2469         Bind interface
 2470        '''
 2471        self.database = database if database is not None else ''
 2472        self.egress_filter = egress_filter if egress_filter is not None else ''
 2473        '''
 2474         A filter applied to the routing logic to pin datasource to nodes.
 2475        '''
 2476        self.healthy = healthy if healthy is not None else False
 2477        '''
 2478         True if the datasource is reachable and the credentials are valid.
 2479        '''
 2480        self.hostname = hostname if hostname is not None else ''
 2481        self.id = id if id is not None else ''
 2482        '''
 2483         Unique identifier of the Resource.
 2484        '''
 2485        self.name = name if name is not None else ''
 2486        '''
 2487         Unique human-readable name of the Resource.
 2488        '''
 2489        self.password = password if password is not None else ''
 2490        self.port = port if port is not None else 0
 2491        self.port_override = port_override if port_override is not None else 0
 2492        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2493        '''
 2494         ID of the secret store containing credentials for this resource, if any.
 2495        '''
 2496        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2497        '''
 2498         Tags is a map of key, value pairs.
 2499        '''
 2500        self.username = username if username is not None else ''
 2501
 2502    def __repr__(self):
 2503        return '<sdm.AuroraMysql ' + \
 2504            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2505            'database: ' + repr(self.database) + ' ' +\
 2506            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2507            'healthy: ' + repr(self.healthy) + ' ' +\
 2508            'hostname: ' + repr(self.hostname) + ' ' +\
 2509            'id: ' + repr(self.id) + ' ' +\
 2510            'name: ' + repr(self.name) + ' ' +\
 2511            'password: ' + repr(self.password) + ' ' +\
 2512            'port: ' + repr(self.port) + ' ' +\
 2513            'port_override: ' + repr(self.port_override) + ' ' +\
 2514            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2515            'tags: ' + repr(self.tags) + ' ' +\
 2516            'username: ' + repr(self.username) + ' ' +\
 2517            '>'
 2518
 2519    def to_dict(self):
 2520        return {
 2521            'bind_interface': self.bind_interface,
 2522            'database': self.database,
 2523            'egress_filter': self.egress_filter,
 2524            'healthy': self.healthy,
 2525            'hostname': self.hostname,
 2526            'id': self.id,
 2527            'name': self.name,
 2528            'password': self.password,
 2529            'port': self.port,
 2530            'port_override': self.port_override,
 2531            'secret_store_id': self.secret_store_id,
 2532            'tags': self.tags,
 2533            'username': self.username,
 2534        }
 2535
 2536    @classmethod
 2537    def from_dict(cls, d):
 2538        return cls(
 2539            bind_interface=d.get('bind_interface'),
 2540            database=d.get('database'),
 2541            egress_filter=d.get('egress_filter'),
 2542            healthy=d.get('healthy'),
 2543            hostname=d.get('hostname'),
 2544            id=d.get('id'),
 2545            name=d.get('name'),
 2546            password=d.get('password'),
 2547            port=d.get('port'),
 2548            port_override=d.get('port_override'),
 2549            secret_store_id=d.get('secret_store_id'),
 2550            tags=d.get('tags'),
 2551            username=d.get('username'),
 2552        )
 2553
 2554
 2555class AuroraPostgres:
 2556    __slots__ = [
 2557        'bind_interface',
 2558        'database',
 2559        'egress_filter',
 2560        'healthy',
 2561        'hostname',
 2562        'id',
 2563        'name',
 2564        'override_database',
 2565        'password',
 2566        'port',
 2567        'port_override',
 2568        'secret_store_id',
 2569        'tags',
 2570        'username',
 2571    ]
 2572
 2573    def __init__(
 2574        self,
 2575        bind_interface=None,
 2576        database=None,
 2577        egress_filter=None,
 2578        healthy=None,
 2579        hostname=None,
 2580        id=None,
 2581        name=None,
 2582        override_database=None,
 2583        password=None,
 2584        port=None,
 2585        port_override=None,
 2586        secret_store_id=None,
 2587        tags=None,
 2588        username=None,
 2589    ):
 2590        self.bind_interface = bind_interface if bind_interface is not None else ''
 2591        '''
 2592         Bind interface
 2593        '''
 2594        self.database = database if database is not None else ''
 2595        self.egress_filter = egress_filter if egress_filter is not None else ''
 2596        '''
 2597         A filter applied to the routing logic to pin datasource to nodes.
 2598        '''
 2599        self.healthy = healthy if healthy is not None else False
 2600        '''
 2601         True if the datasource is reachable and the credentials are valid.
 2602        '''
 2603        self.hostname = hostname if hostname is not None else ''
 2604        self.id = id if id is not None else ''
 2605        '''
 2606         Unique identifier of the Resource.
 2607        '''
 2608        self.name = name if name is not None else ''
 2609        '''
 2610         Unique human-readable name of the Resource.
 2611        '''
 2612        self.override_database = override_database if override_database is not None else False
 2613        self.password = password if password is not None else ''
 2614        self.port = port if port is not None else 0
 2615        self.port_override = port_override if port_override is not None else 0
 2616        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2617        '''
 2618         ID of the secret store containing credentials for this resource, if any.
 2619        '''
 2620        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2621        '''
 2622         Tags is a map of key, value pairs.
 2623        '''
 2624        self.username = username if username is not None else ''
 2625
 2626    def __repr__(self):
 2627        return '<sdm.AuroraPostgres ' + \
 2628            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2629            'database: ' + repr(self.database) + ' ' +\
 2630            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2631            'healthy: ' + repr(self.healthy) + ' ' +\
 2632            'hostname: ' + repr(self.hostname) + ' ' +\
 2633            'id: ' + repr(self.id) + ' ' +\
 2634            'name: ' + repr(self.name) + ' ' +\
 2635            'override_database: ' + repr(self.override_database) + ' ' +\
 2636            'password: ' + repr(self.password) + ' ' +\
 2637            'port: ' + repr(self.port) + ' ' +\
 2638            'port_override: ' + repr(self.port_override) + ' ' +\
 2639            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2640            'tags: ' + repr(self.tags) + ' ' +\
 2641            'username: ' + repr(self.username) + ' ' +\
 2642            '>'
 2643
 2644    def to_dict(self):
 2645        return {
 2646            'bind_interface': self.bind_interface,
 2647            'database': self.database,
 2648            'egress_filter': self.egress_filter,
 2649            'healthy': self.healthy,
 2650            'hostname': self.hostname,
 2651            'id': self.id,
 2652            'name': self.name,
 2653            'override_database': self.override_database,
 2654            'password': self.password,
 2655            'port': self.port,
 2656            'port_override': self.port_override,
 2657            'secret_store_id': self.secret_store_id,
 2658            'tags': self.tags,
 2659            'username': self.username,
 2660        }
 2661
 2662    @classmethod
 2663    def from_dict(cls, d):
 2664        return cls(
 2665            bind_interface=d.get('bind_interface'),
 2666            database=d.get('database'),
 2667            egress_filter=d.get('egress_filter'),
 2668            healthy=d.get('healthy'),
 2669            hostname=d.get('hostname'),
 2670            id=d.get('id'),
 2671            name=d.get('name'),
 2672            override_database=d.get('override_database'),
 2673            password=d.get('password'),
 2674            port=d.get('port'),
 2675            port_override=d.get('port_override'),
 2676            secret_store_id=d.get('secret_store_id'),
 2677            tags=d.get('tags'),
 2678            username=d.get('username'),
 2679        )
 2680
 2681
 2682class Azure:
 2683    __slots__ = [
 2684        'app_id',
 2685        'bind_interface',
 2686        'egress_filter',
 2687        'healthy',
 2688        'id',
 2689        'name',
 2690        'password',
 2691        'secret_store_id',
 2692        'tags',
 2693        'tenant_id',
 2694    ]
 2695
 2696    def __init__(
 2697        self,
 2698        app_id=None,
 2699        bind_interface=None,
 2700        egress_filter=None,
 2701        healthy=None,
 2702        id=None,
 2703        name=None,
 2704        password=None,
 2705        secret_store_id=None,
 2706        tags=None,
 2707        tenant_id=None,
 2708    ):
 2709        self.app_id = app_id if app_id is not None else ''
 2710        self.bind_interface = bind_interface if bind_interface is not None else ''
 2711        '''
 2712         Bind interface
 2713        '''
 2714        self.egress_filter = egress_filter if egress_filter is not None else ''
 2715        '''
 2716         A filter applied to the routing logic to pin datasource to nodes.
 2717        '''
 2718        self.healthy = healthy if healthy is not None else False
 2719        '''
 2720         True if the datasource is reachable and the credentials are valid.
 2721        '''
 2722        self.id = id if id is not None else ''
 2723        '''
 2724         Unique identifier of the Resource.
 2725        '''
 2726        self.name = name if name is not None else ''
 2727        '''
 2728         Unique human-readable name of the Resource.
 2729        '''
 2730        self.password = password if password is not None else ''
 2731        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2732        '''
 2733         ID of the secret store containing credentials for this resource, if any.
 2734        '''
 2735        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2736        '''
 2737         Tags is a map of key, value pairs.
 2738        '''
 2739        self.tenant_id = tenant_id if tenant_id is not None else ''
 2740
 2741    def __repr__(self):
 2742        return '<sdm.Azure ' + \
 2743            'app_id: ' + repr(self.app_id) + ' ' +\
 2744            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2745            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2746            'healthy: ' + repr(self.healthy) + ' ' +\
 2747            'id: ' + repr(self.id) + ' ' +\
 2748            'name: ' + repr(self.name) + ' ' +\
 2749            'password: ' + repr(self.password) + ' ' +\
 2750            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2751            'tags: ' + repr(self.tags) + ' ' +\
 2752            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2753            '>'
 2754
 2755    def to_dict(self):
 2756        return {
 2757            'app_id': self.app_id,
 2758            'bind_interface': self.bind_interface,
 2759            'egress_filter': self.egress_filter,
 2760            'healthy': self.healthy,
 2761            'id': self.id,
 2762            'name': self.name,
 2763            'password': self.password,
 2764            'secret_store_id': self.secret_store_id,
 2765            'tags': self.tags,
 2766            'tenant_id': self.tenant_id,
 2767        }
 2768
 2769    @classmethod
 2770    def from_dict(cls, d):
 2771        return cls(
 2772            app_id=d.get('app_id'),
 2773            bind_interface=d.get('bind_interface'),
 2774            egress_filter=d.get('egress_filter'),
 2775            healthy=d.get('healthy'),
 2776            id=d.get('id'),
 2777            name=d.get('name'),
 2778            password=d.get('password'),
 2779            secret_store_id=d.get('secret_store_id'),
 2780            tags=d.get('tags'),
 2781            tenant_id=d.get('tenant_id'),
 2782        )
 2783
 2784
 2785class AzureCertificate:
 2786    __slots__ = [
 2787        'app_id',
 2788        'bind_interface',
 2789        'client_certificate',
 2790        'egress_filter',
 2791        'healthy',
 2792        'id',
 2793        'name',
 2794        'secret_store_id',
 2795        'tags',
 2796        'tenant_id',
 2797    ]
 2798
 2799    def __init__(
 2800        self,
 2801        app_id=None,
 2802        bind_interface=None,
 2803        client_certificate=None,
 2804        egress_filter=None,
 2805        healthy=None,
 2806        id=None,
 2807        name=None,
 2808        secret_store_id=None,
 2809        tags=None,
 2810        tenant_id=None,
 2811    ):
 2812        self.app_id = app_id if app_id is not None else ''
 2813        self.bind_interface = bind_interface if bind_interface is not None else ''
 2814        '''
 2815         Bind interface
 2816        '''
 2817        self.client_certificate = client_certificate if client_certificate is not None else ''
 2818        self.egress_filter = egress_filter if egress_filter is not None else ''
 2819        '''
 2820         A filter applied to the routing logic to pin datasource to nodes.
 2821        '''
 2822        self.healthy = healthy if healthy is not None else False
 2823        '''
 2824         True if the datasource is reachable and the credentials are valid.
 2825        '''
 2826        self.id = id if id is not None else ''
 2827        '''
 2828         Unique identifier of the Resource.
 2829        '''
 2830        self.name = name if name is not None else ''
 2831        '''
 2832         Unique human-readable name of the Resource.
 2833        '''
 2834        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2835        '''
 2836         ID of the secret store containing credentials for this resource, if any.
 2837        '''
 2838        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2839        '''
 2840         Tags is a map of key, value pairs.
 2841        '''
 2842        self.tenant_id = tenant_id if tenant_id is not None else ''
 2843
 2844    def __repr__(self):
 2845        return '<sdm.AzureCertificate ' + \
 2846            'app_id: ' + repr(self.app_id) + ' ' +\
 2847            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2848            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 2849            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2850            'healthy: ' + repr(self.healthy) + ' ' +\
 2851            'id: ' + repr(self.id) + ' ' +\
 2852            'name: ' + repr(self.name) + ' ' +\
 2853            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2854            'tags: ' + repr(self.tags) + ' ' +\
 2855            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2856            '>'
 2857
 2858    def to_dict(self):
 2859        return {
 2860            'app_id': self.app_id,
 2861            'bind_interface': self.bind_interface,
 2862            'client_certificate': self.client_certificate,
 2863            'egress_filter': self.egress_filter,
 2864            'healthy': self.healthy,
 2865            'id': self.id,
 2866            'name': self.name,
 2867            'secret_store_id': self.secret_store_id,
 2868            'tags': self.tags,
 2869            'tenant_id': self.tenant_id,
 2870        }
 2871
 2872    @classmethod
 2873    def from_dict(cls, d):
 2874        return cls(
 2875            app_id=d.get('app_id'),
 2876            bind_interface=d.get('bind_interface'),
 2877            client_certificate=d.get('client_certificate'),
 2878            egress_filter=d.get('egress_filter'),
 2879            healthy=d.get('healthy'),
 2880            id=d.get('id'),
 2881            name=d.get('name'),
 2882            secret_store_id=d.get('secret_store_id'),
 2883            tags=d.get('tags'),
 2884            tenant_id=d.get('tenant_id'),
 2885        )
 2886
 2887
 2888class AzureMysql:
 2889    '''
 2890    AzureMysql is currently unstable, and its API may change, or it may be removed,
 2891    without a major version bump.
 2892    '''
 2893    __slots__ = [
 2894        'bind_interface',
 2895        'database',
 2896        'egress_filter',
 2897        'healthy',
 2898        'hostname',
 2899        'id',
 2900        'name',
 2901        'password',
 2902        'port',
 2903        'port_override',
 2904        'secret_store_id',
 2905        'tags',
 2906        'username',
 2907    ]
 2908
 2909    def __init__(
 2910        self,
 2911        bind_interface=None,
 2912        database=None,
 2913        egress_filter=None,
 2914        healthy=None,
 2915        hostname=None,
 2916        id=None,
 2917        name=None,
 2918        password=None,
 2919        port=None,
 2920        port_override=None,
 2921        secret_store_id=None,
 2922        tags=None,
 2923        username=None,
 2924    ):
 2925        self.bind_interface = bind_interface if bind_interface is not None else ''
 2926        '''
 2927         Bind interface
 2928        '''
 2929        self.database = database if database is not None else ''
 2930        self.egress_filter = egress_filter if egress_filter is not None else ''
 2931        '''
 2932         A filter applied to the routing logic to pin datasource to nodes.
 2933        '''
 2934        self.healthy = healthy if healthy is not None else False
 2935        '''
 2936         True if the datasource is reachable and the credentials are valid.
 2937        '''
 2938        self.hostname = hostname if hostname is not None else ''
 2939        self.id = id if id is not None else ''
 2940        '''
 2941         Unique identifier of the Resource.
 2942        '''
 2943        self.name = name if name is not None else ''
 2944        '''
 2945         Unique human-readable name of the Resource.
 2946        '''
 2947        self.password = password if password is not None else ''
 2948        self.port = port if port is not None else 0
 2949        self.port_override = port_override if port_override is not None else 0
 2950        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2951        '''
 2952         ID of the secret store containing credentials for this resource, if any.
 2953        '''
 2954        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2955        '''
 2956         Tags is a map of key, value pairs.
 2957        '''
 2958        self.username = username if username is not None else ''
 2959
 2960    def __repr__(self):
 2961        return '<sdm.AzureMysql ' + \
 2962            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2963            'database: ' + repr(self.database) + ' ' +\
 2964            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2965            'healthy: ' + repr(self.healthy) + ' ' +\
 2966            'hostname: ' + repr(self.hostname) + ' ' +\
 2967            'id: ' + repr(self.id) + ' ' +\
 2968            'name: ' + repr(self.name) + ' ' +\
 2969            'password: ' + repr(self.password) + ' ' +\
 2970            'port: ' + repr(self.port) + ' ' +\
 2971            'port_override: ' + repr(self.port_override) + ' ' +\
 2972            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2973            'tags: ' + repr(self.tags) + ' ' +\
 2974            'username: ' + repr(self.username) + ' ' +\
 2975            '>'
 2976
 2977    def to_dict(self):
 2978        return {
 2979            'bind_interface': self.bind_interface,
 2980            'database': self.database,
 2981            'egress_filter': self.egress_filter,
 2982            'healthy': self.healthy,
 2983            'hostname': self.hostname,
 2984            'id': self.id,
 2985            'name': self.name,
 2986            'password': self.password,
 2987            'port': self.port,
 2988            'port_override': self.port_override,
 2989            'secret_store_id': self.secret_store_id,
 2990            'tags': self.tags,
 2991            'username': self.username,
 2992        }
 2993
 2994    @classmethod
 2995    def from_dict(cls, d):
 2996        return cls(
 2997            bind_interface=d.get('bind_interface'),
 2998            database=d.get('database'),
 2999            egress_filter=d.get('egress_filter'),
 3000            healthy=d.get('healthy'),
 3001            hostname=d.get('hostname'),
 3002            id=d.get('id'),
 3003            name=d.get('name'),
 3004            password=d.get('password'),
 3005            port=d.get('port'),
 3006            port_override=d.get('port_override'),
 3007            secret_store_id=d.get('secret_store_id'),
 3008            tags=d.get('tags'),
 3009            username=d.get('username'),
 3010        )
 3011
 3012
 3013class AzurePostgres:
 3014    __slots__ = [
 3015        'bind_interface',
 3016        'database',
 3017        'egress_filter',
 3018        'healthy',
 3019        'hostname',
 3020        'id',
 3021        'name',
 3022        'override_database',
 3023        'password',
 3024        'port',
 3025        'port_override',
 3026        'secret_store_id',
 3027        'tags',
 3028        'username',
 3029    ]
 3030
 3031    def __init__(
 3032        self,
 3033        bind_interface=None,
 3034        database=None,
 3035        egress_filter=None,
 3036        healthy=None,
 3037        hostname=None,
 3038        id=None,
 3039        name=None,
 3040        override_database=None,
 3041        password=None,
 3042        port=None,
 3043        port_override=None,
 3044        secret_store_id=None,
 3045        tags=None,
 3046        username=None,
 3047    ):
 3048        self.bind_interface = bind_interface if bind_interface is not None else ''
 3049        '''
 3050         Bind interface
 3051        '''
 3052        self.database = database if database is not None else ''
 3053        self.egress_filter = egress_filter if egress_filter is not None else ''
 3054        '''
 3055         A filter applied to the routing logic to pin datasource to nodes.
 3056        '''
 3057        self.healthy = healthy if healthy is not None else False
 3058        '''
 3059         True if the datasource is reachable and the credentials are valid.
 3060        '''
 3061        self.hostname = hostname if hostname is not None else ''
 3062        self.id = id if id is not None else ''
 3063        '''
 3064         Unique identifier of the Resource.
 3065        '''
 3066        self.name = name if name is not None else ''
 3067        '''
 3068         Unique human-readable name of the Resource.
 3069        '''
 3070        self.override_database = override_database if override_database is not None else False
 3071        self.password = password if password is not None else ''
 3072        self.port = port if port is not None else 0
 3073        self.port_override = port_override if port_override is not None else 0
 3074        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3075        '''
 3076         ID of the secret store containing credentials for this resource, if any.
 3077        '''
 3078        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3079        '''
 3080         Tags is a map of key, value pairs.
 3081        '''
 3082        self.username = username if username is not None else ''
 3083
 3084    def __repr__(self):
 3085        return '<sdm.AzurePostgres ' + \
 3086            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3087            'database: ' + repr(self.database) + ' ' +\
 3088            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3089            'healthy: ' + repr(self.healthy) + ' ' +\
 3090            'hostname: ' + repr(self.hostname) + ' ' +\
 3091            'id: ' + repr(self.id) + ' ' +\
 3092            'name: ' + repr(self.name) + ' ' +\
 3093            'override_database: ' + repr(self.override_database) + ' ' +\
 3094            'password: ' + repr(self.password) + ' ' +\
 3095            'port: ' + repr(self.port) + ' ' +\
 3096            'port_override: ' + repr(self.port_override) + ' ' +\
 3097            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3098            'tags: ' + repr(self.tags) + ' ' +\
 3099            'username: ' + repr(self.username) + ' ' +\
 3100            '>'
 3101
 3102    def to_dict(self):
 3103        return {
 3104            'bind_interface': self.bind_interface,
 3105            'database': self.database,
 3106            'egress_filter': self.egress_filter,
 3107            'healthy': self.healthy,
 3108            'hostname': self.hostname,
 3109            'id': self.id,
 3110            'name': self.name,
 3111            'override_database': self.override_database,
 3112            'password': self.password,
 3113            'port': self.port,
 3114            'port_override': self.port_override,
 3115            'secret_store_id': self.secret_store_id,
 3116            'tags': self.tags,
 3117            'username': self.username,
 3118        }
 3119
 3120    @classmethod
 3121    def from_dict(cls, d):
 3122        return cls(
 3123            bind_interface=d.get('bind_interface'),
 3124            database=d.get('database'),
 3125            egress_filter=d.get('egress_filter'),
 3126            healthy=d.get('healthy'),
 3127            hostname=d.get('hostname'),
 3128            id=d.get('id'),
 3129            name=d.get('name'),
 3130            override_database=d.get('override_database'),
 3131            password=d.get('password'),
 3132            port=d.get('port'),
 3133            port_override=d.get('port_override'),
 3134            secret_store_id=d.get('secret_store_id'),
 3135            tags=d.get('tags'),
 3136            username=d.get('username'),
 3137        )
 3138
 3139
 3140class AzureStore:
 3141    __slots__ = [
 3142        'id',
 3143        'name',
 3144        'tags',
 3145        'vault_uri',
 3146    ]
 3147
 3148    def __init__(
 3149        self,
 3150        id=None,
 3151        name=None,
 3152        tags=None,
 3153        vault_uri=None,
 3154    ):
 3155        self.id = id if id is not None else ''
 3156        '''
 3157         Unique identifier of the SecretStore.
 3158        '''
 3159        self.name = name if name is not None else ''
 3160        '''
 3161         Unique human-readable name of the SecretStore.
 3162        '''
 3163        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3164        '''
 3165         Tags is a map of key, value pairs.
 3166        '''
 3167        self.vault_uri = vault_uri if vault_uri is not None else ''
 3168
 3169    def __repr__(self):
 3170        return '<sdm.AzureStore ' + \
 3171            'id: ' + repr(self.id) + ' ' +\
 3172            'name: ' + repr(self.name) + ' ' +\
 3173            'tags: ' + repr(self.tags) + ' ' +\
 3174            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
 3175            '>'
 3176
 3177    def to_dict(self):
 3178        return {
 3179            'id': self.id,
 3180            'name': self.name,
 3181            'tags': self.tags,
 3182            'vault_uri': self.vault_uri,
 3183        }
 3184
 3185    @classmethod
 3186    def from_dict(cls, d):
 3187        return cls(
 3188            id=d.get('id'),
 3189            name=d.get('name'),
 3190            tags=d.get('tags'),
 3191            vault_uri=d.get('vault_uri'),
 3192        )
 3193
 3194
 3195class BigQuery:
 3196    __slots__ = [
 3197        'bind_interface',
 3198        'egress_filter',
 3199        'endpoint',
 3200        'healthy',
 3201        'id',
 3202        'name',
 3203        'port_override',
 3204        'private_key',
 3205        'project',
 3206        'secret_store_id',
 3207        'tags',
 3208        'username',
 3209    ]
 3210
 3211    def __init__(
 3212        self,
 3213        bind_interface=None,
 3214        egress_filter=None,
 3215        endpoint=None,
 3216        healthy=None,
 3217        id=None,
 3218        name=None,
 3219        port_override=None,
 3220        private_key=None,
 3221        project=None,
 3222        secret_store_id=None,
 3223        tags=None,
 3224        username=None,
 3225    ):
 3226        self.bind_interface = bind_interface if bind_interface is not None else ''
 3227        '''
 3228         Bind interface
 3229        '''
 3230        self.egress_filter = egress_filter if egress_filter is not None else ''
 3231        '''
 3232         A filter applied to the routing logic to pin datasource to nodes.
 3233        '''
 3234        self.endpoint = endpoint if endpoint is not None else ''
 3235        self.healthy = healthy if healthy is not None else False
 3236        '''
 3237         True if the datasource is reachable and the credentials are valid.
 3238        '''
 3239        self.id = id if id is not None else ''
 3240        '''
 3241         Unique identifier of the Resource.
 3242        '''
 3243        self.name = name if name is not None else ''
 3244        '''
 3245         Unique human-readable name of the Resource.
 3246        '''
 3247        self.port_override = port_override if port_override is not None else 0
 3248        self.private_key = private_key if private_key is not None else ''
 3249        self.project = project if project is not None else ''
 3250        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3251        '''
 3252         ID of the secret store containing credentials for this resource, if any.
 3253        '''
 3254        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3255        '''
 3256         Tags is a map of key, value pairs.
 3257        '''
 3258        self.username = username if username is not None else ''
 3259
 3260    def __repr__(self):
 3261        return '<sdm.BigQuery ' + \
 3262            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3263            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3264            'endpoint: ' + repr(self.endpoint) + ' ' +\
 3265            'healthy: ' + repr(self.healthy) + ' ' +\
 3266            'id: ' + repr(self.id) + ' ' +\
 3267            'name: ' + repr(self.name) + ' ' +\
 3268            'port_override: ' + repr(self.port_override) + ' ' +\
 3269            'private_key: ' + repr(self.private_key) + ' ' +\
 3270            'project: ' + repr(self.project) + ' ' +\
 3271            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3272            'tags: ' + repr(self.tags) + ' ' +\
 3273            'username: ' + repr(self.username) + ' ' +\
 3274            '>'
 3275
 3276    def to_dict(self):
 3277        return {
 3278            'bind_interface': self.bind_interface,
 3279            'egress_filter': self.egress_filter,
 3280            'endpoint': self.endpoint,
 3281            'healthy': self.healthy,
 3282            'id': self.id,
 3283            'name': self.name,
 3284            'port_override': self.port_override,
 3285            'private_key': self.private_key,
 3286            'project': self.project,
 3287            'secret_store_id': self.secret_store_id,
 3288            'tags': self.tags,
 3289            'username': self.username,
 3290        }
 3291
 3292    @classmethod
 3293    def from_dict(cls, d):
 3294        return cls(
 3295            bind_interface=d.get('bind_interface'),
 3296            egress_filter=d.get('egress_filter'),
 3297            endpoint=d.get('endpoint'),
 3298            healthy=d.get('healthy'),
 3299            id=d.get('id'),
 3300            name=d.get('name'),
 3301            port_override=d.get('port_override'),
 3302            private_key=d.get('private_key'),
 3303            project=d.get('project'),
 3304            secret_store_id=d.get('secret_store_id'),
 3305            tags=d.get('tags'),
 3306            username=d.get('username'),
 3307        )
 3308
 3309
 3310class Cassandra:
 3311    __slots__ = [
 3312        'bind_interface',
 3313        'egress_filter',
 3314        'healthy',
 3315        'hostname',
 3316        'id',
 3317        'name',
 3318        'password',
 3319        'port',
 3320        'port_override',
 3321        'secret_store_id',
 3322        'tags',
 3323        'tls_required',
 3324        'username',
 3325    ]
 3326
 3327    def __init__(
 3328        self,
 3329        bind_interface=None,
 3330        egress_filter=None,
 3331        healthy=None,
 3332        hostname=None,
 3333        id=None,
 3334        name=None,
 3335        password=None,
 3336        port=None,
 3337        port_override=None,
 3338        secret_store_id=None,
 3339        tags=None,
 3340        tls_required=None,
 3341        username=None,
 3342    ):
 3343        self.bind_interface = bind_interface if bind_interface is not None else ''
 3344        '''
 3345         Bind interface
 3346        '''
 3347        self.egress_filter = egress_filter if egress_filter is not None else ''
 3348        '''
 3349         A filter applied to the routing logic to pin datasource to nodes.
 3350        '''
 3351        self.healthy = healthy if healthy is not None else False
 3352        '''
 3353         True if the datasource is reachable and the credentials are valid.
 3354        '''
 3355        self.hostname = hostname if hostname is not None else ''
 3356        self.id = id if id is not None else ''
 3357        '''
 3358         Unique identifier of the Resource.
 3359        '''
 3360        self.name = name if name is not None else ''
 3361        '''
 3362         Unique human-readable name of the Resource.
 3363        '''
 3364        self.password = password if password is not None else ''
 3365        self.port = port if port is not None else 0
 3366        self.port_override = port_override if port_override is not None else 0
 3367        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3368        '''
 3369         ID of the secret store containing credentials for this resource, if any.
 3370        '''
 3371        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3372        '''
 3373         Tags is a map of key, value pairs.
 3374        '''
 3375        self.tls_required = tls_required if tls_required is not None else False
 3376        self.username = username if username is not None else ''
 3377
 3378    def __repr__(self):
 3379        return '<sdm.Cassandra ' + \
 3380            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3381            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3382            'healthy: ' + repr(self.healthy) + ' ' +\
 3383            'hostname: ' + repr(self.hostname) + ' ' +\
 3384            'id: ' + repr(self.id) + ' ' +\
 3385            'name: ' + repr(self.name) + ' ' +\
 3386            'password: ' + repr(self.password) + ' ' +\
 3387            'port: ' + repr(self.port) + ' ' +\
 3388            'port_override: ' + repr(self.port_override) + ' ' +\
 3389            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3390            'tags: ' + repr(self.tags) + ' ' +\
 3391            'tls_required: ' + repr(self.tls_required) + ' ' +\
 3392            'username: ' + repr(self.username) + ' ' +\
 3393            '>'
 3394
 3395    def to_dict(self):
 3396        return {
 3397            'bind_interface': self.bind_interface,
 3398            'egress_filter': self.egress_filter,
 3399            'healthy': self.healthy,
 3400            'hostname': self.hostname,
 3401            'id': self.id,
 3402            'name': self.name,
 3403            'password': self.password,
 3404            'port': self.port,
 3405            'port_override': self.port_override,
 3406            'secret_store_id': self.secret_store_id,
 3407            'tags': self.tags,
 3408            'tls_required': self.tls_required,
 3409            'username': self.username,
 3410        }
 3411
 3412    @classmethod
 3413    def from_dict(cls, d):
 3414        return cls(
 3415            bind_interface=d.get('bind_interface'),
 3416            egress_filter=d.get('egress_filter'),
 3417            healthy=d.get('healthy'),
 3418            hostname=d.get('hostname'),
 3419            id=d.get('id'),
 3420            name=d.get('name'),
 3421            password=d.get('password'),
 3422            port=d.get('port'),
 3423            port_override=d.get('port_override'),
 3424            secret_store_id=d.get('secret_store_id'),
 3425            tags=d.get('tags'),
 3426            tls_required=d.get('tls_required'),
 3427            username=d.get('username'),
 3428        )
 3429
 3430
 3431class Citus:
 3432    __slots__ = [
 3433        'bind_interface',
 3434        'database',
 3435        'egress_filter',
 3436        'healthy',
 3437        'hostname',
 3438        'id',
 3439        'name',
 3440        'override_database',
 3441        'password',
 3442        'port',
 3443        'port_override',
 3444        'secret_store_id',
 3445        'tags',
 3446        'username',
 3447    ]
 3448
 3449    def __init__(
 3450        self,
 3451        bind_interface=None,
 3452        database=None,
 3453        egress_filter=None,
 3454        healthy=None,
 3455        hostname=None,
 3456        id=None,
 3457        name=None,
 3458        override_database=None,
 3459        password=None,
 3460        port=None,
 3461        port_override=None,
 3462        secret_store_id=None,
 3463        tags=None,
 3464        username=None,
 3465    ):
 3466        self.bind_interface = bind_interface if bind_interface is not None else ''
 3467        '''
 3468         Bind interface
 3469        '''
 3470        self.database = database if database is not None else ''
 3471        self.egress_filter = egress_filter if egress_filter is not None else ''
 3472        '''
 3473         A filter applied to the routing logic to pin datasource to nodes.
 3474        '''
 3475        self.healthy = healthy if healthy is not None else False
 3476        '''
 3477         True if the datasource is reachable and the credentials are valid.
 3478        '''
 3479        self.hostname = hostname if hostname is not None else ''
 3480        self.id = id if id is not None else ''
 3481        '''
 3482         Unique identifier of the Resource.
 3483        '''
 3484        self.name = name if name is not None else ''
 3485        '''
 3486         Unique human-readable name of the Resource.
 3487        '''
 3488        self.override_database = override_database if override_database is not None else False
 3489        self.password = password if password is not None else ''
 3490        self.port = port if port is not None else 0
 3491        self.port_override = port_override if port_override is not None else 0
 3492        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3493        '''
 3494         ID of the secret store containing credentials for this resource, if any.
 3495        '''
 3496        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3497        '''
 3498         Tags is a map of key, value pairs.
 3499        '''
 3500        self.username = username if username is not None else ''
 3501
 3502    def __repr__(self):
 3503        return '<sdm.Citus ' + \
 3504            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3505            'database: ' + repr(self.database) + ' ' +\
 3506            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3507            'healthy: ' + repr(self.healthy) + ' ' +\
 3508            'hostname: ' + repr(self.hostname) + ' ' +\
 3509            'id: ' + repr(self.id) + ' ' +\
 3510            'name: ' + repr(self.name) + ' ' +\
 3511            'override_database: ' + repr(self.override_database) + ' ' +\
 3512            'password: ' + repr(self.password) + ' ' +\
 3513            'port: ' + repr(self.port) + ' ' +\
 3514            'port_override: ' + repr(self.port_override) + ' ' +\
 3515            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3516            'tags: ' + repr(self.tags) + ' ' +\
 3517            'username: ' + repr(self.username) + ' ' +\
 3518            '>'
 3519
 3520    def to_dict(self):
 3521        return {
 3522            'bind_interface': self.bind_interface,
 3523            'database': self.database,
 3524            'egress_filter': self.egress_filter,
 3525            'healthy': self.healthy,
 3526            'hostname': self.hostname,
 3527            'id': self.id,
 3528            'name': self.name,
 3529            'override_database': self.override_database,
 3530            'password': self.password,
 3531            'port': self.port,
 3532            'port_override': self.port_override,
 3533            'secret_store_id': self.secret_store_id,
 3534            'tags': self.tags,
 3535            'username': self.username,
 3536        }
 3537
 3538    @classmethod
 3539    def from_dict(cls, d):
 3540        return cls(
 3541            bind_interface=d.get('bind_interface'),
 3542            database=d.get('database'),
 3543            egress_filter=d.get('egress_filter'),
 3544            healthy=d.get('healthy'),
 3545            hostname=d.get('hostname'),
 3546            id=d.get('id'),
 3547            name=d.get('name'),
 3548            override_database=d.get('override_database'),
 3549            password=d.get('password'),
 3550            port=d.get('port'),
 3551            port_override=d.get('port_override'),
 3552            secret_store_id=d.get('secret_store_id'),
 3553            tags=d.get('tags'),
 3554            username=d.get('username'),
 3555        )
 3556
 3557
 3558class Clustrix:
 3559    __slots__ = [
 3560        'bind_interface',
 3561        'database',
 3562        'egress_filter',
 3563        'healthy',
 3564        'hostname',
 3565        'id',
 3566        'name',
 3567        'password',
 3568        'port',
 3569        'port_override',
 3570        'secret_store_id',
 3571        'tags',
 3572        'username',
 3573    ]
 3574
 3575    def __init__(
 3576        self,
 3577        bind_interface=None,
 3578        database=None,
 3579        egress_filter=None,
 3580        healthy=None,
 3581        hostname=None,
 3582        id=None,
 3583        name=None,
 3584        password=None,
 3585        port=None,
 3586        port_override=None,
 3587        secret_store_id=None,
 3588        tags=None,
 3589        username=None,
 3590    ):
 3591        self.bind_interface = bind_interface if bind_interface is not None else ''
 3592        '''
 3593         Bind interface
 3594        '''
 3595        self.database = database if database is not None else ''
 3596        self.egress_filter = egress_filter if egress_filter is not None else ''
 3597        '''
 3598         A filter applied to the routing logic to pin datasource to nodes.
 3599        '''
 3600        self.healthy = healthy if healthy is not None else False
 3601        '''
 3602         True if the datasource is reachable and the credentials are valid.
 3603        '''
 3604        self.hostname = hostname if hostname is not None else ''
 3605        self.id = id if id is not None else ''
 3606        '''
 3607         Unique identifier of the Resource.
 3608        '''
 3609        self.name = name if name is not None else ''
 3610        '''
 3611         Unique human-readable name of the Resource.
 3612        '''
 3613        self.password = password if password is not None else ''
 3614        self.port = port if port is not None else 0
 3615        self.port_override = port_override if port_override is not None else 0
 3616        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3617        '''
 3618         ID of the secret store containing credentials for this resource, if any.
 3619        '''
 3620        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3621        '''
 3622         Tags is a map of key, value pairs.
 3623        '''
 3624        self.username = username if username is not None else ''
 3625
 3626    def __repr__(self):
 3627        return '<sdm.Clustrix ' + \
 3628            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3629            'database: ' + repr(self.database) + ' ' +\
 3630            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3631            'healthy: ' + repr(self.healthy) + ' ' +\
 3632            'hostname: ' + repr(self.hostname) + ' ' +\
 3633            'id: ' + repr(self.id) + ' ' +\
 3634            'name: ' + repr(self.name) + ' ' +\
 3635            'password: ' + repr(self.password) + ' ' +\
 3636            'port: ' + repr(self.port) + ' ' +\
 3637            'port_override: ' + repr(self.port_override) + ' ' +\
 3638            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3639            'tags: ' + repr(self.tags) + ' ' +\
 3640            'username: ' + repr(self.username) + ' ' +\
 3641            '>'
 3642
 3643    def to_dict(self):
 3644        return {
 3645            'bind_interface': self.bind_interface,
 3646            'database': self.database,
 3647            'egress_filter': self.egress_filter,
 3648            'healthy': self.healthy,
 3649            'hostname': self.hostname,
 3650            'id': self.id,
 3651            'name': self.name,
 3652            'password': self.password,
 3653            'port': self.port,
 3654            'port_override': self.port_override,
 3655            'secret_store_id': self.secret_store_id,
 3656            'tags': self.tags,
 3657            'username': self.username,
 3658        }
 3659
 3660    @classmethod
 3661    def from_dict(cls, d):
 3662        return cls(
 3663            bind_interface=d.get('bind_interface'),
 3664            database=d.get('database'),
 3665            egress_filter=d.get('egress_filter'),
 3666            healthy=d.get('healthy'),
 3667            hostname=d.get('hostname'),
 3668            id=d.get('id'),
 3669            name=d.get('name'),
 3670            password=d.get('password'),
 3671            port=d.get('port'),
 3672            port_override=d.get('port_override'),
 3673            secret_store_id=d.get('secret_store_id'),
 3674            tags=d.get('tags'),
 3675            username=d.get('username'),
 3676        )
 3677
 3678
 3679class Cockroach:
 3680    __slots__ = [
 3681        'bind_interface',
 3682        'database',
 3683        'egress_filter',
 3684        'healthy',
 3685        'hostname',
 3686        'id',
 3687        'name',
 3688        'override_database',
 3689        'password',
 3690        'port',
 3691        'port_override',
 3692        'secret_store_id',
 3693        'tags',
 3694        'username',
 3695    ]
 3696
 3697    def __init__(
 3698        self,
 3699        bind_interface=None,
 3700        database=None,
 3701        egress_filter=None,
 3702        healthy=None,
 3703        hostname=None,
 3704        id=None,
 3705        name=None,
 3706        override_database=None,
 3707        password=None,
 3708        port=None,
 3709        port_override=None,
 3710        secret_store_id=None,
 3711        tags=None,
 3712        username=None,
 3713    ):
 3714        self.bind_interface = bind_interface if bind_interface is not None else ''
 3715        '''
 3716         Bind interface
 3717        '''
 3718        self.database = database if database is not None else ''
 3719        self.egress_filter = egress_filter if egress_filter is not None else ''
 3720        '''
 3721         A filter applied to the routing logic to pin datasource to nodes.
 3722        '''
 3723        self.healthy = healthy if healthy is not None else False
 3724        '''
 3725         True if the datasource is reachable and the credentials are valid.
 3726        '''
 3727        self.hostname = hostname if hostname is not None else ''
 3728        self.id = id if id is not None else ''
 3729        '''
 3730         Unique identifier of the Resource.
 3731        '''
 3732        self.name = name if name is not None else ''
 3733        '''
 3734         Unique human-readable name of the Resource.
 3735        '''
 3736        self.override_database = override_database if override_database is not None else False
 3737        self.password = password if password is not None else ''
 3738        self.port = port if port is not None else 0
 3739        self.port_override = port_override if port_override is not None else 0
 3740        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3741        '''
 3742         ID of the secret store containing credentials for this resource, if any.
 3743        '''
 3744        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3745        '''
 3746         Tags is a map of key, value pairs.
 3747        '''
 3748        self.username = username if username is not None else ''
 3749
 3750    def __repr__(self):
 3751        return '<sdm.Cockroach ' + \
 3752            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3753            'database: ' + repr(self.database) + ' ' +\
 3754            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3755            'healthy: ' + repr(self.healthy) + ' ' +\
 3756            'hostname: ' + repr(self.hostname) + ' ' +\
 3757            'id: ' + repr(self.id) + ' ' +\
 3758            'name: ' + repr(self.name) + ' ' +\
 3759            'override_database: ' + repr(self.override_database) + ' ' +\
 3760            'password: ' + repr(self.password) + ' ' +\
 3761            'port: ' + repr(self.port) + ' ' +\
 3762            'port_override: ' + repr(self.port_override) + ' ' +\
 3763            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3764            'tags: ' + repr(self.tags) + ' ' +\
 3765            'username: ' + repr(self.username) + ' ' +\
 3766            '>'
 3767
 3768    def to_dict(self):
 3769        return {
 3770            'bind_interface': self.bind_interface,
 3771            'database': self.database,
 3772            'egress_filter': self.egress_filter,
 3773            'healthy': self.healthy,
 3774            'hostname': self.hostname,
 3775            'id': self.id,
 3776            'name': self.name,
 3777            'override_database': self.override_database,
 3778            'password': self.password,
 3779            'port': self.port,
 3780            'port_override': self.port_override,
 3781            'secret_store_id': self.secret_store_id,
 3782            'tags': self.tags,
 3783            'username': self.username,
 3784        }
 3785
 3786    @classmethod
 3787    def from_dict(cls, d):
 3788        return cls(
 3789            bind_interface=d.get('bind_interface'),
 3790            database=d.get('database'),
 3791            egress_filter=d.get('egress_filter'),
 3792            healthy=d.get('healthy'),
 3793            hostname=d.get('hostname'),
 3794            id=d.get('id'),
 3795            name=d.get('name'),
 3796            override_database=d.get('override_database'),
 3797            password=d.get('password'),
 3798            port=d.get('port'),
 3799            port_override=d.get('port_override'),
 3800            secret_store_id=d.get('secret_store_id'),
 3801            tags=d.get('tags'),
 3802            username=d.get('username'),
 3803        )
 3804
 3805
 3806class ControlPanelGetSSHCAPublicKeyResponse:
 3807    '''
 3808         ControlPanelGetSSHCAPublicKeyResponse represents a request for an
 3809     organization's SSH Certificate Authority public key.
 3810    '''
 3811    __slots__ = [
 3812        'meta',
 3813        'public_key',
 3814        'rate_limit',
 3815    ]
 3816
 3817    def __init__(
 3818        self,
 3819        meta=None,
 3820        public_key=None,
 3821        rate_limit=None,
 3822    ):
 3823        self.meta = meta if meta is not None else None
 3824        '''
 3825         Reserved for future use.
 3826        '''
 3827        self.public_key = public_key if public_key is not None else ''
 3828        '''
 3829         The public key of the SSH Certificate Authority, in OpenSSH RSA public
 3830         key format.
 3831        '''
 3832        self.rate_limit = rate_limit if rate_limit is not None else None
 3833        '''
 3834         Rate limit information.
 3835        '''
 3836
 3837    def __repr__(self):
 3838        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
 3839            'meta: ' + repr(self.meta) + ' ' +\
 3840            'public_key: ' + repr(self.public_key) + ' ' +\
 3841            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3842            '>'
 3843
 3844    def to_dict(self):
 3845        return {
 3846            'meta': self.meta,
 3847            'public_key': self.public_key,
 3848            'rate_limit': self.rate_limit,
 3849        }
 3850
 3851    @classmethod
 3852    def from_dict(cls, d):
 3853        return cls(
 3854            meta=d.get('meta'),
 3855            public_key=d.get('public_key'),
 3856            rate_limit=d.get('rate_limit'),
 3857        )
 3858
 3859
 3860class ControlPanelVerifyJWTResponse:
 3861    '''
 3862         ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
 3863    '''
 3864    __slots__ = [
 3865        'meta',
 3866        'rate_limit',
 3867        'valid',
 3868    ]
 3869
 3870    def __init__(
 3871        self,
 3872        meta=None,
 3873        rate_limit=None,
 3874        valid=None,
 3875    ):
 3876        self.meta = meta if meta is not None else None
 3877        '''
 3878         Reserved for future use.
 3879        '''
 3880        self.rate_limit = rate_limit if rate_limit is not None else None
 3881        '''
 3882         Rate limit information.
 3883        '''
 3884        self.valid = valid if valid is not None else False
 3885        '''
 3886         Reports if the given token is valid.
 3887        '''
 3888
 3889    def __repr__(self):
 3890        return '<sdm.ControlPanelVerifyJWTResponse ' + \
 3891            'meta: ' + repr(self.meta) + ' ' +\
 3892            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3893            'valid: ' + repr(self.valid) + ' ' +\
 3894            '>'
 3895
 3896    def to_dict(self):
 3897        return {
 3898            'meta': self.meta,
 3899            'rate_limit': self.rate_limit,
 3900            'valid': self.valid,
 3901        }
 3902
 3903    @classmethod
 3904    def from_dict(cls, d):
 3905        return cls(
 3906            meta=d.get('meta'),
 3907            rate_limit=d.get('rate_limit'),
 3908            valid=d.get('valid'),
 3909        )
 3910
 3911
 3912class CreateResponseMetadata:
 3913    '''
 3914         CreateResponseMetadata is reserved for future use.
 3915    '''
 3916    __slots__ = []
 3917
 3918    def __init__(self, ):
 3919        pass
 3920
 3921    def __repr__(self):
 3922        return '<sdm.CreateResponseMetadata ' + \
 3923            '>'
 3924
 3925    def to_dict(self):
 3926        return {}
 3927
 3928    @classmethod
 3929    def from_dict(cls, d):
 3930        return cls()
 3931
 3932
 3933class CyberarkConjurStore:
 3934    __slots__ = [
 3935        'appurl',
 3936        'id',
 3937        'name',
 3938        'tags',
 3939    ]
 3940
 3941    def __init__(
 3942        self,
 3943        appurl=None,
 3944        id=None,
 3945        name=None,
 3946        tags=None,
 3947    ):
 3948        self.appurl = appurl if appurl is not None else ''
 3949        self.id = id if id is not None else ''
 3950        '''
 3951         Unique identifier of the SecretStore.
 3952        '''
 3953        self.name = name if name is not None else ''
 3954        '''
 3955         Unique human-readable name of the SecretStore.
 3956        '''
 3957        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3958        '''
 3959         Tags is a map of key, value pairs.
 3960        '''
 3961
 3962    def __repr__(self):
 3963        return '<sdm.CyberarkConjurStore ' + \
 3964            'appurl: ' + repr(self.appurl) + ' ' +\
 3965            'id: ' + repr(self.id) + ' ' +\
 3966            'name: ' + repr(self.name) + ' ' +\
 3967            'tags: ' + repr(self.tags) + ' ' +\
 3968            '>'
 3969
 3970    def to_dict(self):
 3971        return {
 3972            'appurl': self.appurl,
 3973            'id': self.id,
 3974            'name': self.name,
 3975            'tags': self.tags,
 3976        }
 3977
 3978    @classmethod
 3979    def from_dict(cls, d):
 3980        return cls(
 3981            appurl=d.get('appurl'),
 3982            id=d.get('id'),
 3983            name=d.get('name'),
 3984            tags=d.get('tags'),
 3985        )
 3986
 3987
 3988class CyberarkPAMExperimentalStore:
 3989    '''
 3990    CyberarkPAMExperimentalStore is currently unstable, and its API may change, or it may be removed,
 3991    without a major version bump.
 3992    '''
 3993    __slots__ = [
 3994        'appurl',
 3995        'id',
 3996        'name',
 3997        'tags',
 3998    ]
 3999
 4000    def __init__(
 4001        self,
 4002        appurl=None,
 4003        id=None,
 4004        name=None,
 4005        tags=None,
 4006    ):
 4007        self.appurl = appurl if appurl is not None else ''
 4008        self.id = id if id is not None else ''
 4009        '''
 4010         Unique identifier of the SecretStore.
 4011        '''
 4012        self.name = name if name is not None else ''
 4013        '''
 4014         Unique human-readable name of the SecretStore.
 4015        '''
 4016        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4017        '''
 4018         Tags is a map of key, value pairs.
 4019        '''
 4020
 4021    def __repr__(self):
 4022        return '<sdm.CyberarkPAMExperimentalStore ' + \
 4023            'appurl: ' + repr(self.appurl) + ' ' +\
 4024            'id: ' + repr(self.id) + ' ' +\
 4025            'name: ' + repr(self.name) + ' ' +\
 4026            'tags: ' + repr(self.tags) + ' ' +\
 4027            '>'
 4028
 4029    def to_dict(self):
 4030        return {
 4031            'appurl': self.appurl,
 4032            'id': self.id,
 4033            'name': self.name,
 4034            'tags': self.tags,
 4035        }
 4036
 4037    @classmethod
 4038    def from_dict(cls, d):
 4039        return cls(
 4040            appurl=d.get('appurl'),
 4041            id=d.get('id'),
 4042            name=d.get('name'),
 4043            tags=d.get('tags'),
 4044        )
 4045
 4046
 4047class CyberarkPAMStore:
 4048    __slots__ = [
 4049        'appurl',
 4050        'id',
 4051        'name',
 4052        'tags',
 4053    ]
 4054
 4055    def __init__(
 4056        self,
 4057        appurl=None,
 4058        id=None,
 4059        name=None,
 4060        tags=None,
 4061    ):
 4062        self.appurl = appurl if appurl is not None else ''
 4063        self.id = id if id is not None else ''
 4064        '''
 4065         Unique identifier of the SecretStore.
 4066        '''
 4067        self.name = name if name is not None else ''
 4068        '''
 4069         Unique human-readable name of the SecretStore.
 4070        '''
 4071        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4072        '''
 4073         Tags is a map of key, value pairs.
 4074        '''
 4075
 4076    def __repr__(self):
 4077        return '<sdm.CyberarkPAMStore ' + \
 4078            'appurl: ' + repr(self.appurl) + ' ' +\
 4079            'id: ' + repr(self.id) + ' ' +\
 4080            'name: ' + repr(self.name) + ' ' +\
 4081            'tags: ' + repr(self.tags) + ' ' +\
 4082            '>'
 4083
 4084    def to_dict(self):
 4085        return {
 4086            'appurl': self.appurl,
 4087            'id': self.id,
 4088            'name': self.name,
 4089            'tags': self.tags,
 4090        }
 4091
 4092    @classmethod
 4093    def from_dict(cls, d):
 4094        return cls(
 4095            appurl=d.get('appurl'),
 4096            id=d.get('id'),
 4097            name=d.get('name'),
 4098            tags=d.get('tags'),
 4099        )
 4100
 4101
 4102class DB2I:
 4103    __slots__ = [
 4104        'bind_interface',
 4105        'egress_filter',
 4106        'healthy',
 4107        'hostname',
 4108        'id',
 4109        'name',
 4110        'password',
 4111        'port',
 4112        'port_override',
 4113        'secret_store_id',
 4114        'tags',
 4115        'tls_required',
 4116        'username',
 4117    ]
 4118
 4119    def __init__(
 4120        self,
 4121        bind_interface=None,
 4122        egress_filter=None,
 4123        healthy=None,
 4124        hostname=None,
 4125        id=None,
 4126        name=None,
 4127        password=None,
 4128        port=None,
 4129        port_override=None,
 4130        secret_store_id=None,
 4131        tags=None,
 4132        tls_required=None,
 4133        username=None,
 4134    ):
 4135        self.bind_interface = bind_interface if bind_interface is not None else ''
 4136        '''
 4137         Bind interface
 4138        '''
 4139        self.egress_filter = egress_filter if egress_filter is not None else ''
 4140        '''
 4141         A filter applied to the routing logic to pin datasource to nodes.
 4142        '''
 4143        self.healthy = healthy if healthy is not None else False
 4144        '''
 4145         True if the datasource is reachable and the credentials are valid.
 4146        '''
 4147        self.hostname = hostname if hostname is not None else ''
 4148        self.id = id if id is not None else ''
 4149        '''
 4150         Unique identifier of the Resource.
 4151        '''
 4152        self.name = name if name is not None else ''
 4153        '''
 4154         Unique human-readable name of the Resource.
 4155        '''
 4156        self.password = password if password is not None else ''
 4157        self.port = port if port is not None else 0
 4158        self.port_override = port_override if port_override is not None else 0
 4159        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4160        '''
 4161         ID of the secret store containing credentials for this resource, if any.
 4162        '''
 4163        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4164        '''
 4165         Tags is a map of key, value pairs.
 4166        '''
 4167        self.tls_required = tls_required if tls_required is not None else False
 4168        self.username = username if username is not None else ''
 4169
 4170    def __repr__(self):
 4171        return '<sdm.DB2I ' + \
 4172            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4173            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4174            'healthy: ' + repr(self.healthy) + ' ' +\
 4175            'hostname: ' + repr(self.hostname) + ' ' +\
 4176            'id: ' + repr(self.id) + ' ' +\
 4177            'name: ' + repr(self.name) + ' ' +\
 4178            'password: ' + repr(self.password) + ' ' +\
 4179            'port: ' + repr(self.port) + ' ' +\
 4180            'port_override: ' + repr(self.port_override) + ' ' +\
 4181            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4182            'tags: ' + repr(self.tags) + ' ' +\
 4183            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4184            'username: ' + repr(self.username) + ' ' +\
 4185            '>'
 4186
 4187    def to_dict(self):
 4188        return {
 4189            'bind_interface': self.bind_interface,
 4190            'egress_filter': self.egress_filter,
 4191            'healthy': self.healthy,
 4192            'hostname': self.hostname,
 4193            'id': self.id,
 4194            'name': self.name,
 4195            'password': self.password,
 4196            'port': self.port,
 4197            'port_override': self.port_override,
 4198            'secret_store_id': self.secret_store_id,
 4199            'tags': self.tags,
 4200            'tls_required': self.tls_required,
 4201            'username': self.username,
 4202        }
 4203
 4204    @classmethod
 4205    def from_dict(cls, d):
 4206        return cls(
 4207            bind_interface=d.get('bind_interface'),
 4208            egress_filter=d.get('egress_filter'),
 4209            healthy=d.get('healthy'),
 4210            hostname=d.get('hostname'),
 4211            id=d.get('id'),
 4212            name=d.get('name'),
 4213            password=d.get('password'),
 4214            port=d.get('port'),
 4215            port_override=d.get('port_override'),
 4216            secret_store_id=d.get('secret_store_id'),
 4217            tags=d.get('tags'),
 4218            tls_required=d.get('tls_required'),
 4219            username=d.get('username'),
 4220        )
 4221
 4222
 4223class DB2LUW:
 4224    __slots__ = [
 4225        'bind_interface',
 4226        'database',
 4227        'egress_filter',
 4228        'healthy',
 4229        'hostname',
 4230        'id',
 4231        'name',
 4232        'password',
 4233        'port',
 4234        'port_override',
 4235        'secret_store_id',
 4236        'tags',
 4237        'username',
 4238    ]
 4239
 4240    def __init__(
 4241        self,
 4242        bind_interface=None,
 4243        database=None,
 4244        egress_filter=None,
 4245        healthy=None,
 4246        hostname=None,
 4247        id=None,
 4248        name=None,
 4249        password=None,
 4250        port=None,
 4251        port_override=None,
 4252        secret_store_id=None,
 4253        tags=None,
 4254        username=None,
 4255    ):
 4256        self.bind_interface = bind_interface if bind_interface is not None else ''
 4257        '''
 4258         Bind interface
 4259        '''
 4260        self.database = database if database is not None else ''
 4261        self.egress_filter = egress_filter if egress_filter is not None else ''
 4262        '''
 4263         A filter applied to the routing logic to pin datasource to nodes.
 4264        '''
 4265        self.healthy = healthy if healthy is not None else False
 4266        '''
 4267         True if the datasource is reachable and the credentials are valid.
 4268        '''
 4269        self.hostname = hostname if hostname is not None else ''
 4270        self.id = id if id is not None else ''
 4271        '''
 4272         Unique identifier of the Resource.
 4273        '''
 4274        self.name = name if name is not None else ''
 4275        '''
 4276         Unique human-readable name of the Resource.
 4277        '''
 4278        self.password = password if password is not None else ''
 4279        self.port = port if port is not None else 0
 4280        self.port_override = port_override if port_override is not None else 0
 4281        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4282        '''
 4283         ID of the secret store containing credentials for this resource, if any.
 4284        '''
 4285        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4286        '''
 4287         Tags is a map of key, value pairs.
 4288        '''
 4289        self.username = username if username is not None else ''
 4290
 4291    def __repr__(self):
 4292        return '<sdm.DB2LUW ' + \
 4293            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4294            'database: ' + repr(self.database) + ' ' +\
 4295            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4296            'healthy: ' + repr(self.healthy) + ' ' +\
 4297            'hostname: ' + repr(self.hostname) + ' ' +\
 4298            'id: ' + repr(self.id) + ' ' +\
 4299            'name: ' + repr(self.name) + ' ' +\
 4300            'password: ' + repr(self.password) + ' ' +\
 4301            'port: ' + repr(self.port) + ' ' +\
 4302            'port_override: ' + repr(self.port_override) + ' ' +\
 4303            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4304            'tags: ' + repr(self.tags) + ' ' +\
 4305            'username: ' + repr(self.username) + ' ' +\
 4306            '>'
 4307
 4308    def to_dict(self):
 4309        return {
 4310            'bind_interface': self.bind_interface,
 4311            'database': self.database,
 4312            'egress_filter': self.egress_filter,
 4313            'healthy': self.healthy,
 4314            'hostname': self.hostname,
 4315            'id': self.id,
 4316            'name': self.name,
 4317            'password': self.password,
 4318            'port': self.port,
 4319            'port_override': self.port_override,
 4320            'secret_store_id': self.secret_store_id,
 4321            'tags': self.tags,
 4322            'username': self.username,
 4323        }
 4324
 4325    @classmethod
 4326    def from_dict(cls, d):
 4327        return cls(
 4328            bind_interface=d.get('bind_interface'),
 4329            database=d.get('database'),
 4330            egress_filter=d.get('egress_filter'),
 4331            healthy=d.get('healthy'),
 4332            hostname=d.get('hostname'),
 4333            id=d.get('id'),
 4334            name=d.get('name'),
 4335            password=d.get('password'),
 4336            port=d.get('port'),
 4337            port_override=d.get('port_override'),
 4338            secret_store_id=d.get('secret_store_id'),
 4339            tags=d.get('tags'),
 4340            username=d.get('username'),
 4341        )
 4342
 4343
 4344class DeleteResponseMetadata:
 4345    '''
 4346         DeleteResponseMetadata is reserved for future use.
 4347    '''
 4348    __slots__ = []
 4349
 4350    def __init__(self, ):
 4351        pass
 4352
 4353    def __repr__(self):
 4354        return '<sdm.DeleteResponseMetadata ' + \
 4355            '>'
 4356
 4357    def to_dict(self):
 4358        return {}
 4359
 4360    @classmethod
 4361    def from_dict(cls, d):
 4362        return cls()
 4363
 4364
 4365class DelineaStore:
 4366    '''
 4367    DelineaStore is currently unstable, and its API may change, or it may be removed,
 4368    without a major version bump.
 4369    '''
 4370    __slots__ = [
 4371        'id',
 4372        'name',
 4373        'server_url',
 4374        'tags',
 4375        'tenant_name',
 4376    ]
 4377
 4378    def __init__(
 4379        self,
 4380        id=None,
 4381        name=None,
 4382        server_url=None,
 4383        tags=None,
 4384        tenant_name=None,
 4385    ):
 4386        self.id = id if id is not None else ''
 4387        '''
 4388         Unique identifier of the SecretStore.
 4389        '''
 4390        self.name = name if name is not None else ''
 4391        '''
 4392         Unique human-readable name of the SecretStore.
 4393        '''
 4394        self.server_url = server_url if server_url is not None else ''
 4395        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4396        '''
 4397         Tags is a map of key, value pairs.
 4398        '''
 4399        self.tenant_name = tenant_name if tenant_name is not None else ''
 4400
 4401    def __repr__(self):
 4402        return '<sdm.DelineaStore ' + \
 4403            'id: ' + repr(self.id) + ' ' +\
 4404            'name: ' + repr(self.name) + ' ' +\
 4405            'server_url: ' + repr(self.server_url) + ' ' +\
 4406            'tags: ' + repr(self.tags) + ' ' +\
 4407            'tenant_name: ' + repr(self.tenant_name) + ' ' +\
 4408            '>'
 4409
 4410    def to_dict(self):
 4411        return {
 4412            'id': self.id,
 4413            'name': self.name,
 4414            'server_url': self.server_url,
 4415            'tags': self.tags,
 4416            'tenant_name': self.tenant_name,
 4417        }
 4418
 4419    @classmethod
 4420    def from_dict(cls, d):
 4421        return cls(
 4422            id=d.get('id'),
 4423            name=d.get('name'),
 4424            server_url=d.get('server_url'),
 4425            tags=d.get('tags'),
 4426            tenant_name=d.get('tenant_name'),
 4427        )
 4428
 4429
 4430class DocumentDBHost:
 4431    __slots__ = [
 4432        'auth_database',
 4433        'bind_interface',
 4434        'egress_filter',
 4435        'healthy',
 4436        'hostname',
 4437        'id',
 4438        'name',
 4439        'password',
 4440        'port',
 4441        'port_override',
 4442        'secret_store_id',
 4443        'tags',
 4444        'username',
 4445    ]
 4446
 4447    def __init__(
 4448        self,
 4449        auth_database=None,
 4450        bind_interface=None,
 4451        egress_filter=None,
 4452        healthy=None,
 4453        hostname=None,
 4454        id=None,
 4455        name=None,
 4456        password=None,
 4457        port=None,
 4458        port_override=None,
 4459        secret_store_id=None,
 4460        tags=None,
 4461        username=None,
 4462    ):
 4463        self.auth_database = auth_database if auth_database is not None else ''
 4464        self.bind_interface = bind_interface if bind_interface is not None else ''
 4465        '''
 4466         Bind interface
 4467        '''
 4468        self.egress_filter = egress_filter if egress_filter is not None else ''
 4469        '''
 4470         A filter applied to the routing logic to pin datasource to nodes.
 4471        '''
 4472        self.healthy = healthy if healthy is not None else False
 4473        '''
 4474         True if the datasource is reachable and the credentials are valid.
 4475        '''
 4476        self.hostname = hostname if hostname is not None else ''
 4477        self.id = id if id is not None else ''
 4478        '''
 4479         Unique identifier of the Resource.
 4480        '''
 4481        self.name = name if name is not None else ''
 4482        '''
 4483         Unique human-readable name of the Resource.
 4484        '''
 4485        self.password = password if password is not None else ''
 4486        self.port = port if port is not None else 0
 4487        self.port_override = port_override if port_override is not None else 0
 4488        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4489        '''
 4490         ID of the secret store containing credentials for this resource, if any.
 4491        '''
 4492        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4493        '''
 4494         Tags is a map of key, value pairs.
 4495        '''
 4496        self.username = username if username is not None else ''
 4497
 4498    def __repr__(self):
 4499        return '<sdm.DocumentDBHost ' + \
 4500            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4501            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4502            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4503            'healthy: ' + repr(self.healthy) + ' ' +\
 4504            'hostname: ' + repr(self.hostname) + ' ' +\
 4505            'id: ' + repr(self.id) + ' ' +\
 4506            'name: ' + repr(self.name) + ' ' +\
 4507            'password: ' + repr(self.password) + ' ' +\
 4508            'port: ' + repr(self.port) + ' ' +\
 4509            'port_override: ' + repr(self.port_override) + ' ' +\
 4510            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4511            'tags: ' + repr(self.tags) + ' ' +\
 4512            'username: ' + repr(self.username) + ' ' +\
 4513            '>'
 4514
 4515    def to_dict(self):
 4516        return {
 4517            'auth_database': self.auth_database,
 4518            'bind_interface': self.bind_interface,
 4519            'egress_filter': self.egress_filter,
 4520            'healthy': self.healthy,
 4521            'hostname': self.hostname,
 4522            'id': self.id,
 4523            'name': self.name,
 4524            'password': self.password,
 4525            'port': self.port,
 4526            'port_override': self.port_override,
 4527            'secret_store_id': self.secret_store_id,
 4528            'tags': self.tags,
 4529            'username': self.username,
 4530        }
 4531
 4532    @classmethod
 4533    def from_dict(cls, d):
 4534        return cls(
 4535            auth_database=d.get('auth_database'),
 4536            bind_interface=d.get('bind_interface'),
 4537            egress_filter=d.get('egress_filter'),
 4538            healthy=d.get('healthy'),
 4539            hostname=d.get('hostname'),
 4540            id=d.get('id'),
 4541            name=d.get('name'),
 4542            password=d.get('password'),
 4543            port=d.get('port'),
 4544            port_override=d.get('port_override'),
 4545            secret_store_id=d.get('secret_store_id'),
 4546            tags=d.get('tags'),
 4547            username=d.get('username'),
 4548        )
 4549
 4550
 4551class DocumentDBReplicaSet:
 4552    __slots__ = [
 4553        'auth_database',
 4554        'bind_interface',
 4555        'connect_to_replica',
 4556        'egress_filter',
 4557        'healthy',
 4558        'hostname',
 4559        'id',
 4560        'name',
 4561        'password',
 4562        'port_override',
 4563        'replica_set',
 4564        'secret_store_id',
 4565        'tags',
 4566        'username',
 4567    ]
 4568
 4569    def __init__(
 4570        self,
 4571        auth_database=None,
 4572        bind_interface=None,
 4573        connect_to_replica=None,
 4574        egress_filter=None,
 4575        healthy=None,
 4576        hostname=None,
 4577        id=None,
 4578        name=None,
 4579        password=None,
 4580        port_override=None,
 4581        replica_set=None,
 4582        secret_store_id=None,
 4583        tags=None,
 4584        username=None,
 4585    ):
 4586        self.auth_database = auth_database if auth_database is not None else ''
 4587        self.bind_interface = bind_interface if bind_interface is not None else ''
 4588        '''
 4589         Bind interface
 4590        '''
 4591        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 4592        self.egress_filter = egress_filter if egress_filter is not None else ''
 4593        '''
 4594         A filter applied to the routing logic to pin datasource to nodes.
 4595        '''
 4596        self.healthy = healthy if healthy is not None else False
 4597        '''
 4598         True if the datasource is reachable and the credentials are valid.
 4599        '''
 4600        self.hostname = hostname if hostname is not None else ''
 4601        '''
 4602         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
 4603        '''
 4604        self.id = id if id is not None else ''
 4605        '''
 4606         Unique identifier of the Resource.
 4607        '''
 4608        self.name = name if name is not None else ''
 4609        '''
 4610         Unique human-readable name of the Resource.
 4611        '''
 4612        self.password = password if password is not None else ''
 4613        self.port_override = port_override if port_override is not None else 0
 4614        self.replica_set = replica_set if replica_set is not None else ''
 4615        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4616        '''
 4617         ID of the secret store containing credentials for this resource, if any.
 4618        '''
 4619        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4620        '''
 4621         Tags is a map of key, value pairs.
 4622        '''
 4623        self.username = username if username is not None else ''
 4624
 4625    def __repr__(self):
 4626        return '<sdm.DocumentDBReplicaSet ' + \
 4627            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4628            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4629            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 4630            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4631            'healthy: ' + repr(self.healthy) + ' ' +\
 4632            'hostname: ' + repr(self.hostname) + ' ' +\
 4633            'id: ' + repr(self.id) + ' ' +\
 4634            'name: ' + repr(self.name) + ' ' +\
 4635            'password: ' + repr(self.password) + ' ' +\
 4636            'port_override: ' + repr(self.port_override) + ' ' +\
 4637            'replica_set: ' + repr(self.replica_set) + ' ' +\
 4638            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4639            'tags: ' + repr(self.tags) + ' ' +\
 4640            'username: ' + repr(self.username) + ' ' +\
 4641            '>'
 4642
 4643    def to_dict(self):
 4644        return {
 4645            'auth_database': self.auth_database,
 4646            'bind_interface': self.bind_interface,
 4647            'connect_to_replica': self.connect_to_replica,
 4648            'egress_filter': self.egress_filter,
 4649            'healthy': self.healthy,
 4650            'hostname': self.hostname,
 4651            'id': self.id,
 4652            'name': self.name,
 4653            'password': self.password,
 4654            'port_override': self.port_override,
 4655            'replica_set': self.replica_set,
 4656            'secret_store_id': self.secret_store_id,
 4657            'tags': self.tags,
 4658            'username': self.username,
 4659        }
 4660
 4661    @classmethod
 4662    def from_dict(cls, d):
 4663        return cls(
 4664            auth_database=d.get('auth_database'),
 4665            bind_interface=d.get('bind_interface'),
 4666            connect_to_replica=d.get('connect_to_replica'),
 4667            egress_filter=d.get('egress_filter'),
 4668            healthy=d.get('healthy'),
 4669            hostname=d.get('hostname'),
 4670            id=d.get('id'),
 4671            name=d.get('name'),
 4672            password=d.get('password'),
 4673            port_override=d.get('port_override'),
 4674            replica_set=d.get('replica_set'),
 4675            secret_store_id=d.get('secret_store_id'),
 4676            tags=d.get('tags'),
 4677            username=d.get('username'),
 4678        )
 4679
 4680
 4681class Druid:
 4682    __slots__ = [
 4683        'bind_interface',
 4684        'egress_filter',
 4685        'healthy',
 4686        'hostname',
 4687        'id',
 4688        'name',
 4689        'password',
 4690        'port',
 4691        'port_override',
 4692        'secret_store_id',
 4693        'tags',
 4694        'username',
 4695    ]
 4696
 4697    def __init__(
 4698        self,
 4699        bind_interface=None,
 4700        egress_filter=None,
 4701        healthy=None,
 4702        hostname=None,
 4703        id=None,
 4704        name=None,
 4705        password=None,
 4706        port=None,
 4707        port_override=None,
 4708        secret_store_id=None,
 4709        tags=None,
 4710        username=None,
 4711    ):
 4712        self.bind_interface = bind_interface if bind_interface is not None else ''
 4713        '''
 4714         Bind interface
 4715        '''
 4716        self.egress_filter = egress_filter if egress_filter is not None else ''
 4717        '''
 4718         A filter applied to the routing logic to pin datasource to nodes.
 4719        '''
 4720        self.healthy = healthy if healthy is not None else False
 4721        '''
 4722         True if the datasource is reachable and the credentials are valid.
 4723        '''
 4724        self.hostname = hostname if hostname is not None else ''
 4725        self.id = id if id is not None else ''
 4726        '''
 4727         Unique identifier of the Resource.
 4728        '''
 4729        self.name = name if name is not None else ''
 4730        '''
 4731         Unique human-readable name of the Resource.
 4732        '''
 4733        self.password = password if password is not None else ''
 4734        self.port = port if port is not None else 0
 4735        self.port_override = port_override if port_override is not None else 0
 4736        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4737        '''
 4738         ID of the secret store containing credentials for this resource, if any.
 4739        '''
 4740        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4741        '''
 4742         Tags is a map of key, value pairs.
 4743        '''
 4744        self.username = username if username is not None else ''
 4745
 4746    def __repr__(self):
 4747        return '<sdm.Druid ' + \
 4748            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4749            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4750            'healthy: ' + repr(self.healthy) + ' ' +\
 4751            'hostname: ' + repr(self.hostname) + ' ' +\
 4752            'id: ' + repr(self.id) + ' ' +\
 4753            'name: ' + repr(self.name) + ' ' +\
 4754            'password: ' + repr(self.password) + ' ' +\
 4755            'port: ' + repr(self.port) + ' ' +\
 4756            'port_override: ' + repr(self.port_override) + ' ' +\
 4757            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4758            'tags: ' + repr(self.tags) + ' ' +\
 4759            'username: ' + repr(self.username) + ' ' +\
 4760            '>'
 4761
 4762    def to_dict(self):
 4763        return {
 4764            'bind_interface': self.bind_interface,
 4765            'egress_filter': self.egress_filter,
 4766            'healthy': self.healthy,
 4767            'hostname': self.hostname,
 4768            'id': self.id,
 4769            'name': self.name,
 4770            'password': self.password,
 4771            'port': self.port,
 4772            'port_override': self.port_override,
 4773            'secret_store_id': self.secret_store_id,
 4774            'tags': self.tags,
 4775            'username': self.username,
 4776        }
 4777
 4778    @classmethod
 4779    def from_dict(cls, d):
 4780        return cls(
 4781            bind_interface=d.get('bind_interface'),
 4782            egress_filter=d.get('egress_filter'),
 4783            healthy=d.get('healthy'),
 4784            hostname=d.get('hostname'),
 4785            id=d.get('id'),
 4786            name=d.get('name'),
 4787            password=d.get('password'),
 4788            port=d.get('port'),
 4789            port_override=d.get('port_override'),
 4790            secret_store_id=d.get('secret_store_id'),
 4791            tags=d.get('tags'),
 4792            username=d.get('username'),
 4793        )
 4794
 4795
 4796class DynamoDB:
 4797    __slots__ = [
 4798        'access_key',
 4799        'bind_interface',
 4800        'egress_filter',
 4801        'endpoint',
 4802        'healthy',
 4803        'id',
 4804        'name',
 4805        'port_override',
 4806        'region',
 4807        'role_arn',
 4808        'role_external_id',
 4809        'secret_access_key',
 4810        'secret_store_id',
 4811        'tags',
 4812    ]
 4813
 4814    def __init__(
 4815        self,
 4816        access_key=None,
 4817        bind_interface=None,
 4818        egress_filter=None,
 4819        endpoint=None,
 4820        healthy=None,
 4821        id=None,
 4822        name=None,
 4823        port_override=None,
 4824        region=None,
 4825        role_arn=None,
 4826        role_external_id=None,
 4827        secret_access_key=None,
 4828        secret_store_id=None,
 4829        tags=None,
 4830    ):
 4831        self.access_key = access_key if access_key is not None else ''
 4832        self.bind_interface = bind_interface if bind_interface is not None else ''
 4833        '''
 4834         Bind interface
 4835        '''
 4836        self.egress_filter = egress_filter if egress_filter is not None else ''
 4837        '''
 4838         A filter applied to the routing logic to pin datasource to nodes.
 4839        '''
 4840        self.endpoint = endpoint if endpoint is not None else ''
 4841        self.healthy = healthy if healthy is not None else False
 4842        '''
 4843         True if the datasource is reachable and the credentials are valid.
 4844        '''
 4845        self.id = id if id is not None else ''
 4846        '''
 4847         Unique identifier of the Resource.
 4848        '''
 4849        self.name = name if name is not None else ''
 4850        '''
 4851         Unique human-readable name of the Resource.
 4852        '''
 4853        self.port_override = port_override if port_override is not None else 0
 4854        self.region = region if region is not None else ''
 4855        self.role_arn = role_arn if role_arn is not None else ''
 4856        self.role_external_id = role_external_id if role_external_id is not None else ''
 4857        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 4858        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4859        '''
 4860         ID of the secret store containing credentials for this resource, if any.
 4861        '''
 4862        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4863        '''
 4864         Tags is a map of key, value pairs.
 4865        '''
 4866
 4867    def __repr__(self):
 4868        return '<sdm.DynamoDB ' + \
 4869            'access_key: ' + repr(self.access_key) + ' ' +\
 4870            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4871            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4872            'endpoint: ' + repr(self.endpoint) + ' ' +\
 4873            'healthy: ' + repr(self.healthy) + ' ' +\
 4874            'id: ' + repr(self.id) + ' ' +\
 4875            'name: ' + repr(self.name) + ' ' +\
 4876            'port_override: ' + repr(self.port_override) + ' ' +\
 4877            'region: ' + repr(self.region) + ' ' +\
 4878            'role_arn: ' + repr(self.role_arn) + ' ' +\
 4879            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 4880            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 4881            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4882            'tags: ' + repr(self.tags) + ' ' +\
 4883            '>'
 4884
 4885    def to_dict(self):
 4886        return {
 4887            'access_key': self.access_key,
 4888            'bind_interface': self.bind_interface,
 4889            'egress_filter': self.egress_filter,
 4890            'endpoint': self.endpoint,
 4891            'healthy': self.healthy,
 4892            'id': self.id,
 4893            'name': self.name,
 4894            'port_override': self.port_override,
 4895            'region': self.region,
 4896            'role_arn': self.role_arn,
 4897            'role_external_id': self.role_external_id,
 4898            'secret_access_key': self.secret_access_key,
 4899            'secret_store_id': self.secret_store_id,
 4900            'tags': self.tags,
 4901        }
 4902
 4903    @classmethod
 4904    def from_dict(cls, d):
 4905        return cls(
 4906            access_key=d.get('access_key'),
 4907            bind_interface=d.get('bind_interface'),
 4908            egress_filter=d.get('egress_filter'),
 4909            endpoint=d.get('endpoint'),
 4910            healthy=d.get('healthy'),
 4911            id=d.get('id'),
 4912            name=d.get('name'),
 4913            port_override=d.get('port_override'),
 4914            region=d.get('region'),
 4915            role_arn=d.get('role_arn'),
 4916            role_external_id=d.get('role_external_id'),
 4917            secret_access_key=d.get('secret_access_key'),
 4918            secret_store_id=d.get('secret_store_id'),
 4919            tags=d.get('tags'),
 4920        )
 4921
 4922
 4923class Elastic:
 4924    __slots__ = [
 4925        'bind_interface',
 4926        'egress_filter',
 4927        'healthy',
 4928        'hostname',
 4929        'id',
 4930        'name',
 4931        'password',
 4932        'port',
 4933        'port_override',
 4934        'secret_store_id',
 4935        'tags',
 4936        'tls_required',
 4937        'username',
 4938    ]
 4939
 4940    def __init__(
 4941        self,
 4942        bind_interface=None,
 4943        egress_filter=None,
 4944        healthy=None,
 4945        hostname=None,
 4946        id=None,
 4947        name=None,
 4948        password=None,
 4949        port=None,
 4950        port_override=None,
 4951        secret_store_id=None,
 4952        tags=None,
 4953        tls_required=None,
 4954        username=None,
 4955    ):
 4956        self.bind_interface = bind_interface if bind_interface is not None else ''
 4957        '''
 4958         Bind interface
 4959        '''
 4960        self.egress_filter = egress_filter if egress_filter is not None else ''
 4961        '''
 4962         A filter applied to the routing logic to pin datasource to nodes.
 4963        '''
 4964        self.healthy = healthy if healthy is not None else False
 4965        '''
 4966         True if the datasource is reachable and the credentials are valid.
 4967        '''
 4968        self.hostname = hostname if hostname is not None else ''
 4969        self.id = id if id is not None else ''
 4970        '''
 4971         Unique identifier of the Resource.
 4972        '''
 4973        self.name = name if name is not None else ''
 4974        '''
 4975         Unique human-readable name of the Resource.
 4976        '''
 4977        self.password = password if password is not None else ''
 4978        self.port = port if port is not None else 0
 4979        self.port_override = port_override if port_override is not None else 0
 4980        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4981        '''
 4982         ID of the secret store containing credentials for this resource, if any.
 4983        '''
 4984        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4985        '''
 4986         Tags is a map of key, value pairs.
 4987        '''
 4988        self.tls_required = tls_required if tls_required is not None else False
 4989        self.username = username if username is not None else ''
 4990
 4991    def __repr__(self):
 4992        return '<sdm.Elastic ' + \
 4993            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4994            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4995            'healthy: ' + repr(self.healthy) + ' ' +\
 4996            'hostname: ' + repr(self.hostname) + ' ' +\
 4997            'id: ' + repr(self.id) + ' ' +\
 4998            'name: ' + repr(self.name) + ' ' +\
 4999            'password: ' + repr(self.password) + ' ' +\
 5000            'port: ' + repr(self.port) + ' ' +\
 5001            'port_override: ' + repr(self.port_override) + ' ' +\
 5002            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5003            'tags: ' + repr(self.tags) + ' ' +\
 5004            'tls_required: ' + repr(self.tls_required) + ' ' +\
 5005            'username: ' + repr(self.username) + ' ' +\
 5006            '>'
 5007
 5008    def to_dict(self):
 5009        return {
 5010            'bind_interface': self.bind_interface,
 5011            'egress_filter': self.egress_filter,
 5012            'healthy': self.healthy,
 5013            'hostname': self.hostname,
 5014            'id': self.id,
 5015            'name': self.name,
 5016            'password': self.password,
 5017            'port': self.port,
 5018            'port_override': self.port_override,
 5019            'secret_store_id': self.secret_store_id,
 5020            'tags': self.tags,
 5021            'tls_required': self.tls_required,
 5022            'username': self.username,
 5023        }
 5024
 5025    @classmethod
 5026    def from_dict(cls, d):
 5027        return cls(
 5028            bind_interface=d.get('bind_interface'),
 5029            egress_filter=d.get('egress_filter'),
 5030            healthy=d.get('healthy'),
 5031            hostname=d.get('hostname'),
 5032            id=d.get('id'),
 5033            name=d.get('name'),
 5034            password=d.get('password'),
 5035            port=d.get('port'),
 5036            port_override=d.get('port_override'),
 5037            secret_store_id=d.get('secret_store_id'),
 5038            tags=d.get('tags'),
 5039            tls_required=d.get('tls_required'),
 5040            username=d.get('username'),
 5041        )
 5042
 5043
 5044class ElasticacheRedis:
 5045    __slots__ = [
 5046        'bind_interface',
 5047        'egress_filter',
 5048        'healthy',
 5049        'hostname',
 5050        'id',
 5051        'name',
 5052        'password',
 5053        'port',
 5054        'port_override',
 5055        'secret_store_id',
 5056        'tags',
 5057        'tls_required',
 5058        'username',
 5059    ]
 5060
 5061    def __init__(
 5062        self,
 5063        bind_interface=None,
 5064        egress_filter=None,
 5065        healthy=None,
 5066        hostname=None,
 5067        id=None,
 5068        name=None,
 5069        password=None,
 5070        port=None,
 5071        port_override=None,
 5072        secret_store_id=None,
 5073        tags=None,
 5074        tls_required=None,
 5075        username=None,
 5076    ):
 5077        self.bind_interface = bind_interface if bind_interface is not None else ''
 5078        '''
 5079         Bind interface
 5080        '''
 5081        self.egress_filter = egress_filter if egress_filter is not None else ''
 5082        '''
 5083         A filter applied to the routing logic to pin datasource to nodes.
 5084        '''
 5085        self.healthy = healthy if healthy is not None else False
 5086        '''
 5087         True if the datasource is reachable and the credentials are valid.
 5088        '''
 5089        self.hostname = hostname if hostname is not None else ''
 5090        self.id = id if id is not None else ''
 5091        '''
 5092         Unique identifier of the Resource.
 5093        '''
 5094        self.name = name if name is not None else ''
 5095        '''
 5096         Unique human-readable name of the Resource.
 5097        '''
 5098        self.password = password if password is not None else ''
 5099        self.port = port if port is not None else 0
 5100        self.port_override = port_override if port_override is not None else 0
 5101        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5102        '''
 5103         ID of the secret store containing credentials for this resource, if any.
 5104        '''
 5105        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5106        '''
 5107         Tags is a map of key, value pairs.
 5108        '''
 5109        self.tls_required = tls_required if tls_required is not None else False
 5110        self.username = username if username is not None else ''
 5111
 5112    def __repr__(self):
 5113        return '<sdm.ElasticacheRedis ' + \
 5114            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5115            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5116            'healthy: ' + repr(self.healthy) + ' ' +\
 5117            'hostname: ' + repr(self.hostname) + ' ' +\
 5118            'id: ' + repr(self.id) + ' ' +\
 5119            'name: ' + repr(self.name) + ' ' +\
 5120            'password: ' + repr(self.password) + ' ' +\
 5121            'port: ' + repr(self.port) + ' ' +\
 5122            'port_override: ' + repr(self.port_override) + ' ' +\
 5123            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5124            'tags: ' + repr(self.tags) + ' ' +\
 5125            'tls_required: ' + repr(self.tls_required) + ' ' +\
 5126            'username: ' + repr(self.username) + ' ' +\
 5127            '>'
 5128
 5129    def to_dict(self):
 5130        return {
 5131            'bind_interface': self.bind_interface,
 5132            'egress_filter': self.egress_filter,
 5133            'healthy': self.healthy,
 5134            'hostname': self.hostname,
 5135            'id': self.id,
 5136            'name': self.name,
 5137            'password': self.password,
 5138            'port': self.port,
 5139            'port_override': self.port_override,
 5140            'secret_store_id': self.secret_store_id,
 5141            'tags': self.tags,
 5142            'tls_required': self.tls_required,
 5143            'username': self.username,
 5144        }
 5145
 5146    @classmethod
 5147    def from_dict(cls, d):
 5148        return cls(
 5149            bind_interface=d.get('bind_interface'),
 5150            egress_filter=d.get('egress_filter'),
 5151            healthy=d.get('healthy'),
 5152            hostname=d.get('hostname'),
 5153            id=d.get('id'),
 5154            name=d.get('name'),
 5155            password=d.get('password'),
 5156            port=d.get('port'),
 5157            port_override=d.get('port_override'),
 5158            secret_store_id=d.get('secret_store_id'),
 5159            tags=d.get('tags'),
 5160            tls_required=d.get('tls_required'),
 5161            username=d.get('username'),
 5162        )
 5163
 5164
 5165class GCP:
 5166    __slots__ = [
 5167        'bind_interface',
 5168        'egress_filter',
 5169        'healthy',
 5170        'id',
 5171        'keyfile',
 5172        'name',
 5173        'scopes',
 5174        'secret_store_id',
 5175        'tags',
 5176    ]
 5177
 5178    def __init__(
 5179        self,
 5180        bind_interface=None,
 5181        egress_filter=None,
 5182        healthy=None,
 5183        id=None,
 5184        keyfile=None,
 5185        name=None,
 5186        scopes=None,
 5187        secret_store_id=None,
 5188        tags=None,
 5189    ):
 5190        self.bind_interface = bind_interface if bind_interface is not None else ''
 5191        '''
 5192         Bind interface
 5193        '''
 5194        self.egress_filter = egress_filter if egress_filter is not None else ''
 5195        '''
 5196         A filter applied to the routing logic to pin datasource to nodes.
 5197        '''
 5198        self.healthy = healthy if healthy is not None else False
 5199        '''
 5200         True if the datasource is reachable and the credentials are valid.
 5201        '''
 5202        self.id = id if id is not None else ''
 5203        '''
 5204         Unique identifier of the Resource.
 5205        '''
 5206        self.keyfile = keyfile if keyfile is not None else ''
 5207        self.name = name if name is not None else ''
 5208        '''
 5209         Unique human-readable name of the Resource.
 5210        '''
 5211        self.scopes = scopes if scopes is not None else ''
 5212        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5213        '''
 5214         ID of the secret store containing credentials for this resource, if any.
 5215        '''
 5216        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5217        '''
 5218         Tags is a map of key, value pairs.
 5219        '''
 5220
 5221    def __repr__(self):
 5222        return '<sdm.GCP ' + \
 5223            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5224            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5225            'healthy: ' + repr(self.healthy) + ' ' +\
 5226            'id: ' + repr(self.id) + ' ' +\
 5227            'keyfile: ' + repr(self.keyfile) + ' ' +\
 5228            'name: ' + repr(self.name) + ' ' +\
 5229            'scopes: ' + repr(self.scopes) + ' ' +\
 5230            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5231            'tags: ' + repr(self.tags) + ' ' +\
 5232            '>'
 5233
 5234    def to_dict(self):
 5235        return {
 5236            'bind_interface': self.bind_interface,
 5237            'egress_filter': self.egress_filter,
 5238            'healthy': self.healthy,
 5239            'id': self.id,
 5240            'keyfile': self.keyfile,
 5241            'name': self.name,
 5242            'scopes': self.scopes,
 5243            'secret_store_id': self.secret_store_id,
 5244            'tags': self.tags,
 5245        }
 5246
 5247    @classmethod
 5248    def from_dict(cls, d):
 5249        return cls(
 5250            bind_interface=d.get('bind_interface'),
 5251            egress_filter=d.get('egress_filter'),
 5252            healthy=d.get('healthy'),
 5253            id=d.get('id'),
 5254            keyfile=d.get('keyfile'),
 5255            name=d.get('name'),
 5256            scopes=d.get('scopes'),
 5257            secret_store_id=d.get('secret_store_id'),
 5258            tags=d.get('tags'),
 5259        )
 5260
 5261
 5262class GCPStore:
 5263    __slots__ = [
 5264        'id',
 5265        'name',
 5266        'projectid',
 5267        'tags',
 5268    ]
 5269
 5270    def __init__(
 5271        self,
 5272        id=None,
 5273        name=None,
 5274        projectid=None,
 5275        tags=None,
 5276    ):
 5277        self.id = id if id is not None else ''
 5278        '''
 5279         Unique identifier of the SecretStore.
 5280        '''
 5281        self.name = name if name is not None else ''
 5282        '''
 5283         Unique human-readable name of the SecretStore.
 5284        '''
 5285        self.projectid = projectid if projectid is not None else ''
 5286        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5287        '''
 5288         Tags is a map of key, value pairs.
 5289        '''
 5290
 5291    def __repr__(self):
 5292        return '<sdm.GCPStore ' + \
 5293            'id: ' + repr(self.id) + ' ' +\
 5294            'name: ' + repr(self.name) + ' ' +\
 5295            'projectid: ' + repr(self.projectid) + ' ' +\
 5296            'tags: ' + repr(self.tags) + ' ' +\
 5297            '>'
 5298
 5299    def to_dict(self):
 5300        return {
 5301            'id': self.id,
 5302            'name': self.name,
 5303            'projectid': self.projectid,
 5304            'tags': self.tags,
 5305        }
 5306
 5307    @classmethod
 5308    def from_dict(cls, d):
 5309        return cls(
 5310            id=d.get('id'),
 5311            name=d.get('name'),
 5312            projectid=d.get('projectid'),
 5313            tags=d.get('tags'),
 5314        )
 5315
 5316
 5317class Gateway:
 5318    '''
 5319         Gateway represents a StrongDM CLI installation running in gateway mode.
 5320    '''
 5321    __slots__ = [
 5322        'bind_address',
 5323        'device',
 5324        'gateway_filter',
 5325        'id',
 5326        'listen_address',
 5327        'location',
 5328        'name',
 5329        'state',
 5330        'tags',
 5331        'version',
 5332    ]
 5333
 5334    def __init__(
 5335        self,
 5336        bind_address=None,
 5337        device=None,
 5338        gateway_filter=None,
 5339        id=None,
 5340        listen_address=None,
 5341        location=None,
 5342        name=None,
 5343        state=None,
 5344        tags=None,
 5345        version=None,
 5346    ):
 5347        self.bind_address = bind_address if bind_address is not None else ''
 5348        '''
 5349         The hostname/port tuple which the gateway daemon will bind to.
 5350         If not provided on create, set to "0.0.0.0:listen_address_port".
 5351        '''
 5352        self.device = device if device is not None else ''
 5353        '''
 5354         Device is a read only device name uploaded by the gateway process when 
 5355         it comes online.
 5356        '''
 5357        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
 5358        '''
 5359         GatewayFilter can be used to restrict the peering between relays and
 5360         gateways.
 5361        '''
 5362        self.id = id if id is not None else ''
 5363        '''
 5364         Unique identifier of the Gateway.
 5365        '''
 5366        self.listen_address = listen_address if listen_address is not None else ''
 5367        '''
 5368         The public hostname/port tuple at which the gateway will be accessible to clients.
 5369        '''
 5370        self.location = location if location is not None else ''
 5371        '''
 5372         Location is a read only network location uploaded by the gateway process
 5373         when it comes online.
 5374        '''
 5375        self.name = name if name is not None else ''
 5376        '''
 5377         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
 5378        '''
 5379        self.state = state if state is not None else ''
 5380        '''
 5381         The current state of the gateway. One of: "new", "verifying_restart",
 5382         "restarting", "started", "stopped", "dead", "unknown"
 5383        '''
 5384        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5385        '''
 5386         Tags is a map of key, value pairs.
 5387        '''
 5388        self.version = version if version is not None else ''
 5389        '''
 5390         Version is a read only sdm binary version uploaded by the gateway process
 5391         when it comes online.
 5392        '''
 5393
 5394    def __repr__(self):
 5395        return '<sdm.Gateway ' + \
 5396            'bind_address: ' + repr(self.bind_address) + ' ' +\
 5397            'device: ' + repr(self.device) + ' ' +\
 5398            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
 5399            'id: ' + repr(self.id) + ' ' +\
 5400            'listen_address: ' + repr(self.listen_address) + ' ' +\
 5401            'location: ' + repr(self.location) + ' ' +\
 5402            'name: ' + repr(self.name) + ' ' +\
 5403            'state: ' + repr(self.state) + ' ' +\
 5404            'tags: ' + repr(self.tags) + ' ' +\
 5405            'version: ' + repr(self.version) + ' ' +\
 5406            '>'
 5407
 5408    def to_dict(self):
 5409        return {
 5410            'bind_address': self.bind_address,
 5411            'device': self.device,
 5412            'gateway_filter': self.gateway_filter,
 5413            'id': self.id,
 5414            'listen_address': self.listen_address,
 5415            'location': self.location,
 5416            'name': self.name,
 5417            'state': self.state,
 5418            'tags': self.tags,
 5419            'version': self.version,
 5420        }
 5421
 5422    @classmethod
 5423    def from_dict(cls, d):
 5424        return cls(
 5425            bind_address=d.get('bind_address'),
 5426            device=d.get('device'),
 5427            gateway_filter=d.get('gateway_filter'),
 5428            id=d.get('id'),
 5429            listen_address=d.get('listen_address'),
 5430            location=d.get('location'),
 5431            name=d.get('name'),
 5432            state=d.get('state'),
 5433            tags=d.get('tags'),
 5434            version=d.get('version'),
 5435        )
 5436
 5437
 5438class GetResponseMetadata:
 5439    '''
 5440         GetResponseMetadata is reserved for future use.
 5441    '''
 5442    __slots__ = []
 5443
 5444    def __init__(self, ):
 5445        pass
 5446
 5447    def __repr__(self):
 5448        return '<sdm.GetResponseMetadata ' + \
 5449            '>'
 5450
 5451    def to_dict(self):
 5452        return {}
 5453
 5454    @classmethod
 5455    def from_dict(cls, d):
 5456        return cls()
 5457
 5458
 5459class GoogleGKE:
 5460    __slots__ = [
 5461        'bind_interface',
 5462        'certificate_authority',
 5463        'egress_filter',
 5464        'endpoint',
 5465        'healthcheck_namespace',
 5466        'healthy',
 5467        'id',
 5468        'name',
 5469        'remote_identity_group_id',
 5470        'remote_identity_healthcheck_username',
 5471        'secret_store_id',
 5472        'service_account_key',
 5473        'tags',
 5474    ]
 5475
 5476    def __init__(
 5477        self,
 5478        bind_interface=None,
 5479        certificate_authority=None,
 5480        egress_filter=None,
 5481        endpoint=None,
 5482        healthcheck_namespace=None,
 5483        healthy=None,
 5484        id=None,
 5485        name=None,
 5486        remote_identity_group_id=None,
 5487        remote_identity_healthcheck_username=None,
 5488        secret_store_id=None,
 5489        service_account_key=None,
 5490        tags=None,
 5491    ):
 5492        self.bind_interface = bind_interface if bind_interface is not None else ''
 5493        '''
 5494         Bind interface
 5495        '''
 5496        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5497        self.egress_filter = egress_filter if egress_filter is not None else ''
 5498        '''
 5499         A filter applied to the routing logic to pin datasource to nodes.
 5500        '''
 5501        self.endpoint = endpoint if endpoint is not None else ''
 5502        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5503        '''
 5504         The path used to check the health of your connection.  Defaults to `default`.
 5505        '''
 5506        self.healthy = healthy if healthy is not None else False
 5507        '''
 5508         True if the datasource is reachable and the credentials are valid.
 5509        '''
 5510        self.id = id if id is not None else ''
 5511        '''
 5512         Unique identifier of the Resource.
 5513        '''
 5514        self.name = name if name is not None else ''
 5515        '''
 5516         Unique human-readable name of the Resource.
 5517        '''
 5518        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 5519        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 5520        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5521        '''
 5522         ID of the secret store containing credentials for this resource, if any.
 5523        '''
 5524        self.service_account_key = service_account_key if service_account_key is not None else ''
 5525        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5526        '''
 5527         Tags is a map of key, value pairs.
 5528        '''
 5529
 5530    def __repr__(self):
 5531        return '<sdm.GoogleGKE ' + \
 5532            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5533            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5534            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5535            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5536            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5537            'healthy: ' + repr(self.healthy) + ' ' +\
 5538            'id: ' + repr(self.id) + ' ' +\
 5539            'name: ' + repr(self.name) + ' ' +\
 5540            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 5541            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 5542            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5543            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5544            'tags: ' + repr(self.tags) + ' ' +\
 5545            '>'
 5546
 5547    def to_dict(self):
 5548        return {
 5549            'bind_interface': self.bind_interface,
 5550            'certificate_authority': self.certificate_authority,
 5551            'egress_filter': self.egress_filter,
 5552            'endpoint': self.endpoint,
 5553            'healthcheck_namespace': self.healthcheck_namespace,
 5554            'healthy': self.healthy,
 5555            'id': self.id,
 5556            'name': self.name,
 5557            'remote_identity_group_id': self.remote_identity_group_id,
 5558            'remote_identity_healthcheck_username':
 5559            self.remote_identity_healthcheck_username,
 5560            'secret_store_id': self.secret_store_id,
 5561            'service_account_key': self.service_account_key,
 5562            'tags': self.tags,
 5563        }
 5564
 5565    @classmethod
 5566    def from_dict(cls, d):
 5567        return cls(
 5568            bind_interface=d.get('bind_interface'),
 5569            certificate_authority=d.get('certificate_authority'),
 5570            egress_filter=d.get('egress_filter'),
 5571            endpoint=d.get('endpoint'),
 5572            healthcheck_namespace=d.get('healthcheck_namespace'),
 5573            healthy=d.get('healthy'),
 5574            id=d.get('id'),
 5575            name=d.get('name'),
 5576            remote_identity_group_id=d.get('remote_identity_group_id'),
 5577            remote_identity_healthcheck_username=d.get(
 5578                'remote_identity_healthcheck_username'),
 5579            secret_store_id=d.get('secret_store_id'),
 5580            service_account_key=d.get('service_account_key'),
 5581            tags=d.get('tags'),
 5582        )
 5583
 5584
 5585class GoogleGKEUserImpersonation:
 5586    __slots__ = [
 5587        'bind_interface',
 5588        'certificate_authority',
 5589        'egress_filter',
 5590        'endpoint',
 5591        'healthcheck_namespace',
 5592        'healthy',
 5593        'id',
 5594        'name',
 5595        'secret_store_id',
 5596        'service_account_key',
 5597        'tags',
 5598    ]
 5599
 5600    def __init__(
 5601        self,
 5602        bind_interface=None,
 5603        certificate_authority=None,
 5604        egress_filter=None,
 5605        endpoint=None,
 5606        healthcheck_namespace=None,
 5607        healthy=None,
 5608        id=None,
 5609        name=None,
 5610        secret_store_id=None,
 5611        service_account_key=None,
 5612        tags=None,
 5613    ):
 5614        self.bind_interface = bind_interface if bind_interface is not None else ''
 5615        '''
 5616         Bind interface
 5617        '''
 5618        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5619        self.egress_filter = egress_filter if egress_filter is not None else ''
 5620        '''
 5621         A filter applied to the routing logic to pin datasource to nodes.
 5622        '''
 5623        self.endpoint = endpoint if endpoint is not None else ''
 5624        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5625        '''
 5626         The path used to check the health of your connection.  Defaults to `default`.
 5627        '''
 5628        self.healthy = healthy if healthy is not None else False
 5629        '''
 5630         True if the datasource is reachable and the credentials are valid.
 5631        '''
 5632        self.id = id if id is not None else ''
 5633        '''
 5634         Unique identifier of the Resource.
 5635        '''
 5636        self.name = name if name is not None else ''
 5637        '''
 5638         Unique human-readable name of the Resource.
 5639        '''
 5640        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5641        '''
 5642         ID of the secret store containing credentials for this resource, if any.
 5643        '''
 5644        self.service_account_key = service_account_key if service_account_key is not None else ''
 5645        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5646        '''
 5647         Tags is a map of key, value pairs.
 5648        '''
 5649
 5650    def __repr__(self):
 5651        return '<sdm.GoogleGKEUserImpersonation ' + \
 5652            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5653            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5654            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5655            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5656            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5657            'healthy: ' + repr(self.healthy) + ' ' +\
 5658            'id: ' + repr(self.id) + ' ' +\
 5659            'name: ' + repr(self.name) + ' ' +\
 5660            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5661            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5662            'tags: ' + repr(self.tags) + ' ' +\
 5663            '>'
 5664
 5665    def to_dict(self):
 5666        return {
 5667            'bind_interface': self.bind_interface,
 5668            'certificate_authority': self.certificate_authority,
 5669            'egress_filter': self.egress_filter,
 5670            'endpoint': self.endpoint,
 5671            'healthcheck_namespace': self.healthcheck_namespace,
 5672            'healthy': self.healthy,
 5673            'id': self.id,
 5674            'name': self.name,
 5675            'secret_store_id': self.secret_store_id,
 5676            'service_account_key': self.service_account_key,
 5677            'tags': self.tags,
 5678        }
 5679
 5680    @classmethod
 5681    def from_dict(cls, d):
 5682        return cls(
 5683            bind_interface=d.get('bind_interface'),
 5684            certificate_authority=d.get('certificate_authority'),
 5685            egress_filter=d.get('egress_filter'),
 5686            endpoint=d.get('endpoint'),
 5687            healthcheck_namespace=d.get('healthcheck_namespace'),
 5688            healthy=d.get('healthy'),
 5689            id=d.get('id'),
 5690            name=d.get('name'),
 5691            secret_store_id=d.get('secret_store_id'),
 5692            service_account_key=d.get('service_account_key'),
 5693            tags=d.get('tags'),
 5694        )
 5695
 5696
 5697class Greenplum:
 5698    __slots__ = [
 5699        'bind_interface',
 5700        'database',
 5701        'egress_filter',
 5702        'healthy',
 5703        'hostname',
 5704        'id',
 5705        'name',
 5706        'override_database',
 5707        'password',
 5708        'port',
 5709        'port_override',
 5710        'secret_store_id',
 5711        'tags',
 5712        'username',
 5713    ]
 5714
 5715    def __init__(
 5716        self,
 5717        bind_interface=None,
 5718        database=None,
 5719        egress_filter=None,
 5720        healthy=None,
 5721        hostname=None,
 5722        id=None,
 5723        name=None,
 5724        override_database=None,
 5725        password=None,
 5726        port=None,
 5727        port_override=None,
 5728        secret_store_id=None,
 5729        tags=None,
 5730        username=None,
 5731    ):
 5732        self.bind_interface = bind_interface if bind_interface is not None else ''
 5733        '''
 5734         Bind interface
 5735        '''
 5736        self.database = database if database is not None else ''
 5737        self.egress_filter = egress_filter if egress_filter is not None else ''
 5738        '''
 5739         A filter applied to the routing logic to pin datasource to nodes.
 5740        '''
 5741        self.healthy = healthy if healthy is not None else False
 5742        '''
 5743         True if the datasource is reachable and the credentials are valid.
 5744        '''
 5745        self.hostname = hostname if hostname is not None else ''
 5746        self.id = id if id is not None else ''
 5747        '''
 5748         Unique identifier of the Resource.
 5749        '''
 5750        self.name = name if name is not None else ''
 5751        '''
 5752         Unique human-readable name of the Resource.
 5753        '''
 5754        self.override_database = override_database if override_database is not None else False
 5755        self.password = password if password is not None else ''
 5756        self.port = port if port is not None else 0
 5757        self.port_override = port_override if port_override is not None else 0
 5758        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5759        '''
 5760         ID of the secret store containing credentials for this resource, if any.
 5761        '''
 5762        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5763        '''
 5764         Tags is a map of key, value pairs.
 5765        '''
 5766        self.username = username if username is not None else ''
 5767
 5768    def __repr__(self):
 5769        return '<sdm.Greenplum ' + \
 5770            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5771            'database: ' + repr(self.database) + ' ' +\
 5772            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5773            'healthy: ' + repr(self.healthy) + ' ' +\
 5774            'hostname: ' + repr(self.hostname) + ' ' +\
 5775            'id: ' + repr(self.id) + ' ' +\
 5776            'name: ' + repr(self.name) + ' ' +\
 5777            'override_database: ' + repr(self.override_database) + ' ' +\
 5778            'password: ' + repr(self.password) + ' ' +\
 5779            'port: ' + repr(self.port) + ' ' +\
 5780            'port_override: ' + repr(self.port_override) + ' ' +\
 5781            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5782            'tags: ' + repr(self.tags) + ' ' +\
 5783            'username: ' + repr(self.username) + ' ' +\
 5784            '>'
 5785
 5786    def to_dict(self):
 5787        return {
 5788            'bind_interface': self.bind_interface,
 5789            'database': self.database,
 5790            'egress_filter': self.egress_filter,
 5791            'healthy': self.healthy,
 5792            'hostname': self.hostname,
 5793            'id': self.id,
 5794            'name': self.name,
 5795            'override_database': self.override_database,
 5796            'password': self.password,
 5797            'port': self.port,
 5798            'port_override': self.port_override,
 5799            'secret_store_id': self.secret_store_id,
 5800            'tags': self.tags,
 5801            'username': self.username,
 5802        }
 5803
 5804    @classmethod
 5805    def from_dict(cls, d):
 5806        return cls(
 5807            bind_interface=d.get('bind_interface'),
 5808            database=d.get('database'),
 5809            egress_filter=d.get('egress_filter'),
 5810            healthy=d.get('healthy'),
 5811            hostname=d.get('hostname'),
 5812            id=d.get('id'),
 5813            name=d.get('name'),
 5814            override_database=d.get('override_database'),
 5815            password=d.get('password'),
 5816            port=d.get('port'),
 5817            port_override=d.get('port_override'),
 5818            secret_store_id=d.get('secret_store_id'),
 5819            tags=d.get('tags'),
 5820            username=d.get('username'),
 5821        )
 5822
 5823
 5824class HTTPAuth:
 5825    __slots__ = [
 5826        'auth_header',
 5827        'bind_interface',
 5828        'default_path',
 5829        'egress_filter',
 5830        'headers_blacklist',
 5831        'healthcheck_path',
 5832        'healthy',
 5833        'host_override',
 5834        'id',
 5835        'name',
 5836        'secret_store_id',
 5837        'subdomain',
 5838        'tags',
 5839        'url',
 5840    ]
 5841
 5842    def __init__(
 5843        self,
 5844        auth_header=None,
 5845        bind_interface=None,
 5846        default_path=None,
 5847        egress_filter=None,
 5848        headers_blacklist=None,
 5849        healthcheck_path=None,
 5850        healthy=None,
 5851        host_override=None,
 5852        id=None,
 5853        name=None,
 5854        secret_store_id=None,
 5855        subdomain=None,
 5856        tags=None,
 5857        url=None,
 5858    ):
 5859        self.auth_header = auth_header if auth_header is not None else ''
 5860        self.bind_interface = bind_interface if bind_interface is not None else ''
 5861        '''
 5862         Bind interface
 5863        '''
 5864        self.default_path = default_path if default_path is not None else ''
 5865        self.egress_filter = egress_filter if egress_filter is not None else ''
 5866        '''
 5867         A filter applied to the routing logic to pin datasource to nodes.
 5868        '''
 5869        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5870        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5871        self.healthy = healthy if healthy is not None else False
 5872        '''
 5873         True if the datasource is reachable and the credentials are valid.
 5874        '''
 5875        self.host_override = host_override if host_override is not None else ''
 5876        self.id = id if id is not None else ''
 5877        '''
 5878         Unique identifier of the Resource.
 5879        '''
 5880        self.name = name if name is not None else ''
 5881        '''
 5882         Unique human-readable name of the Resource.
 5883        '''
 5884        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5885        '''
 5886         ID of the secret store containing credentials for this resource, if any.
 5887        '''
 5888        self.subdomain = subdomain if subdomain is not None else ''
 5889        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5890        '''
 5891         Tags is a map of key, value pairs.
 5892        '''
 5893        self.url = url if url is not None else ''
 5894
 5895    def __repr__(self):
 5896        return '<sdm.HTTPAuth ' + \
 5897            'auth_header: ' + repr(self.auth_header) + ' ' +\
 5898            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5899            'default_path: ' + repr(self.default_path) + ' ' +\
 5900            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5901            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 5902            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 5903            'healthy: ' + repr(self.healthy) + ' ' +\
 5904            'host_override: ' + repr(self.host_override) + ' ' +\
 5905            'id: ' + repr(self.id) + ' ' +\
 5906            'name: ' + repr(self.name) + ' ' +\
 5907            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5908            'subdomain: ' + repr(self.subdomain) + ' ' +\
 5909            'tags: ' + repr(self.tags) + ' ' +\
 5910            'url: ' + repr(self.url) + ' ' +\
 5911            '>'
 5912
 5913    def to_dict(self):
 5914        return {
 5915            'auth_header': self.auth_header,
 5916            'bind_interface': self.bind_interface,
 5917            'default_path': self.default_path,
 5918            'egress_filter': self.egress_filter,
 5919            'headers_blacklist': self.headers_blacklist,
 5920            'healthcheck_path': self.healthcheck_path,
 5921            'healthy': self.healthy,
 5922            'host_override': self.host_override,
 5923            'id': self.id,
 5924            'name': self.name,
 5925            'secret_store_id': self.secret_store_id,
 5926            'subdomain': self.subdomain,
 5927            'tags': self.tags,
 5928            'url': self.url,
 5929        }
 5930
 5931    @classmethod
 5932    def from_dict(cls, d):
 5933        return cls(
 5934            auth_header=d.get('auth_header'),
 5935            bind_interface=d.get('bind_interface'),
 5936            default_path=d.get('default_path'),
 5937            egress_filter=d.get('egress_filter'),
 5938            headers_blacklist=d.get('headers_blacklist'),
 5939            healthcheck_path=d.get('healthcheck_path'),
 5940            healthy=d.get('healthy'),
 5941            host_override=d.get('host_override'),
 5942            id=d.get('id'),
 5943            name=d.get('name'),
 5944            secret_store_id=d.get('secret_store_id'),
 5945            subdomain=d.get('subdomain'),
 5946            tags=d.get('tags'),
 5947            url=d.get('url'),
 5948        )
 5949
 5950
 5951class HTTPBasicAuth:
 5952    __slots__ = [
 5953        'bind_interface',
 5954        'default_path',
 5955        'egress_filter',
 5956        'headers_blacklist',
 5957        'healthcheck_path',
 5958        'healthy',
 5959        'host_override',
 5960        'id',
 5961        'name',
 5962        'password',
 5963        'secret_store_id',
 5964        'subdomain',
 5965        'tags',
 5966        'url',
 5967        'username',
 5968    ]
 5969
 5970    def __init__(
 5971        self,
 5972        bind_interface=None,
 5973        default_path=None,
 5974        egress_filter=None,
 5975        headers_blacklist=None,
 5976        healthcheck_path=None,
 5977        healthy=None,
 5978        host_override=None,
 5979        id=None,
 5980        name=None,
 5981        password=None,
 5982        secret_store_id=None,
 5983        subdomain=None,
 5984        tags=None,
 5985        url=None,
 5986        username=None,
 5987    ):
 5988        self.bind_interface = bind_interface if bind_interface is not None else ''
 5989        '''
 5990         Bind interface
 5991        '''
 5992        self.default_path = default_path if default_path is not None else ''
 5993        self.egress_filter = egress_filter if egress_filter is not None else ''
 5994        '''
 5995         A filter applied to the routing logic to pin datasource to nodes.
 5996        '''
 5997        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5998        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5999        self.healthy = healthy if healthy is not None else False
 6000        '''
 6001         True if the datasource is reachable and the credentials are valid.
 6002        '''
 6003        self.host_override = host_override if host_override is not None else ''
 6004        self.id = id if id is not None else ''
 6005        '''
 6006         Unique identifier of the Resource.
 6007        '''
 6008        self.name = name if name is not None else ''
 6009        '''
 6010         Unique human-readable name of the Resource.
 6011        '''
 6012        self.password = password if password is not None else ''
 6013        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6014        '''
 6015         ID of the secret store containing credentials for this resource, if any.
 6016        '''
 6017        self.subdomain = subdomain if subdomain is not None else ''
 6018        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6019        '''
 6020         Tags is a map of key, value pairs.
 6021        '''
 6022        self.url = url if url is not None else ''
 6023        self.username = username if username is not None else ''
 6024
 6025    def __repr__(self):
 6026        return '<sdm.HTTPBasicAuth ' + \
 6027            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6028            'default_path: ' + repr(self.default_path) + ' ' +\
 6029            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6030            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 6031            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 6032            'healthy: ' + repr(self.healthy) + ' ' +\
 6033            'host_override: ' + repr(self.host_override) + ' ' +\
 6034            'id: ' + repr(self.id) + ' ' +\
 6035            'name: ' + repr(self.name) + ' ' +\
 6036            'password: ' + repr(self.password) + ' ' +\
 6037            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6038            'subdomain: ' + repr(self.subdomain) + ' ' +\
 6039            'tags: ' + repr(self.tags) + ' ' +\
 6040            'url: ' + repr(self.url) + ' ' +\
 6041            'username: ' + repr(self.username) + ' ' +\
 6042            '>'
 6043
 6044    def to_dict(self):
 6045        return {
 6046            'bind_interface': self.bind_interface,
 6047            'default_path': self.default_path,
 6048            'egress_filter': self.egress_filter,
 6049            'headers_blacklist': self.headers_blacklist,
 6050            'healthcheck_path': self.healthcheck_path,
 6051            'healthy': self.healthy,
 6052            'host_override': self.host_override,
 6053            'id': self.id,
 6054            'name': self.name,
 6055            'password': self.password,
 6056            'secret_store_id': self.secret_store_id,
 6057            'subdomain': self.subdomain,
 6058            'tags': self.tags,
 6059            'url': self.url,
 6060            'username': self.username,
 6061        }
 6062
 6063    @classmethod
 6064    def from_dict(cls, d):
 6065        return cls(
 6066            bind_interface=d.get('bind_interface'),
 6067            default_path=d.get('default_path'),
 6068            egress_filter=d.get('egress_filter'),
 6069            headers_blacklist=d.get('headers_blacklist'),
 6070            healthcheck_path=d.get('healthcheck_path'),
 6071            healthy=d.get('healthy'),
 6072            host_override=d.get('host_override'),
 6073            id=d.get('id'),
 6074            name=d.get('name'),
 6075            password=d.get('password'),
 6076            secret_store_id=d.get('secret_store_id'),
 6077            subdomain=d.get('subdomain'),
 6078            tags=d.get('tags'),
 6079            url=d.get('url'),
 6080            username=d.get('username'),
 6081        )
 6082
 6083
 6084class HTTPNoAuth:
 6085    __slots__ = [
 6086        'bind_interface',
 6087        'default_path',
 6088        'egress_filter',
 6089        'headers_blacklist',
 6090        'healthcheck_path',
 6091        'healthy',
 6092        'host_override',
 6093        'id',
 6094        'name',
 6095        'secret_store_id',
 6096        'subdomain',
 6097        'tags',
 6098        'url',
 6099    ]
 6100
 6101    def __init__(
 6102        self,
 6103        bind_interface=None,
 6104        default_path=None,
 6105        egress_filter=None,
 6106        headers_blacklist=None,
 6107        healthcheck_path=None,
 6108        healthy=None,
 6109        host_override=None,
 6110        id=None,
 6111        name=None,
 6112        secret_store_id=None,
 6113        subdomain=None,
 6114        tags=None,
 6115        url=None,
 6116    ):
 6117        self.bind_interface = bind_interface if bind_interface is not None else ''
 6118        '''
 6119         Bind interface
 6120        '''
 6121        self.default_path = default_path if default_path is not None else ''
 6122        self.egress_filter = egress_filter if egress_filter is not None else ''
 6123        '''
 6124         A filter applied to the routing logic to pin datasource to nodes.
 6125        '''
 6126        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 6127        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 6128        self.healthy = healthy if healthy is not None else False
 6129        '''
 6130         True if the datasource is reachable and the credentials are valid.
 6131        '''
 6132        self.host_override = host_override if host_override is not None else ''
 6133        self.id = id if id is not None else ''
 6134        '''
 6135         Unique identifier of the Resource.
 6136        '''
 6137        self.name = name if name is not None else ''
 6138        '''
 6139         Unique human-readable name of the Resource.
 6140        '''
 6141        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6142        '''
 6143         ID of the secret store containing credentials for this resource, if any.
 6144        '''
 6145        self.subdomain = subdomain if subdomain is not None else ''
 6146        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6147        '''
 6148         Tags is a map of key, value pairs.
 6149        '''
 6150        self.url = url if url is not None else ''
 6151
 6152    def __repr__(self):
 6153        return '<sdm.HTTPNoAuth ' + \
 6154            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6155            'default_path: ' + repr(self.default_path) + ' ' +\
 6156            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6157            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 6158            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 6159            'healthy: ' + repr(self.healthy) + ' ' +\
 6160            'host_override: ' + repr(self.host_override) + ' ' +\
 6161            'id: ' + repr(self.id) + ' ' +\
 6162            'name: ' + repr(self.name) + ' ' +\
 6163            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6164            'subdomain: ' + repr(self.subdomain) + ' ' +\
 6165            'tags: ' + repr(self.tags) + ' ' +\
 6166            'url: ' + repr(self.url) + ' ' +\
 6167            '>'
 6168
 6169    def to_dict(self):
 6170        return {
 6171            'bind_interface': self.bind_interface,
 6172            'default_path': self.default_path,
 6173            'egress_filter': self.egress_filter,
 6174            'headers_blacklist': self.headers_blacklist,
 6175            'healthcheck_path': self.healthcheck_path,
 6176            'healthy': self.healthy,
 6177            'host_override': self.host_override,
 6178            'id': self.id,
 6179            'name': self.name,
 6180            'secret_store_id': self.secret_store_id,
 6181            'subdomain': self.subdomain,
 6182            'tags': self.tags,
 6183            'url': self.url,
 6184        }
 6185
 6186    @classmethod
 6187    def from_dict(cls, d):
 6188        return cls(
 6189            bind_interface=d.get('bind_interface'),
 6190            default_path=d.get('default_path'),
 6191            egress_filter=d.get('egress_filter'),
 6192            headers_blacklist=d.get('headers_blacklist'),
 6193            healthcheck_path=d.get('healthcheck_path'),
 6194            healthy=d.get('healthy'),
 6195            host_override=d.get('host_override'),
 6196            id=d.get('id'),
 6197            name=d.get('name'),
 6198            secret_store_id=d.get('secret_store_id'),
 6199            subdomain=d.get('subdomain'),
 6200            tags=d.get('tags'),
 6201            url=d.get('url'),
 6202        )
 6203
 6204
 6205class Kubernetes:
 6206    __slots__ = [
 6207        'bind_interface',
 6208        'certificate_authority',
 6209        'client_certificate',
 6210        'client_key',
 6211        'egress_filter',
 6212        'healthcheck_namespace',
 6213        'healthy',
 6214        'hostname',
 6215        'id',
 6216        'name',
 6217        'port',
 6218        'port_override',
 6219        'remote_identity_group_id',
 6220        'remote_identity_healthcheck_username',
 6221        'secret_store_id',
 6222        'tags',
 6223    ]
 6224
 6225    def __init__(
 6226        self,
 6227        bind_interface=None,
 6228        certificate_authority=None,
 6229        client_certificate=None,
 6230        client_key=None,
 6231        egress_filter=None,
 6232        healthcheck_namespace=None,
 6233        healthy=None,
 6234        hostname=None,
 6235        id=None,
 6236        name=None,
 6237        port=None,
 6238        port_override=None,
 6239        remote_identity_group_id=None,
 6240        remote_identity_healthcheck_username=None,
 6241        secret_store_id=None,
 6242        tags=None,
 6243    ):
 6244        self.bind_interface = bind_interface if bind_interface is not None else ''
 6245        '''
 6246         Bind interface
 6247        '''
 6248        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6249        self.client_certificate = client_certificate if client_certificate is not None else ''
 6250        self.client_key = client_key if client_key is not None else ''
 6251        self.egress_filter = egress_filter if egress_filter is not None else ''
 6252        '''
 6253         A filter applied to the routing logic to pin datasource to nodes.
 6254        '''
 6255        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6256        '''
 6257         The path used to check the health of your connection.  Defaults to `default`.
 6258        '''
 6259        self.healthy = healthy if healthy is not None else False
 6260        '''
 6261         True if the datasource is reachable and the credentials are valid.
 6262        '''
 6263        self.hostname = hostname if hostname is not None else ''
 6264        self.id = id if id is not None else ''
 6265        '''
 6266         Unique identifier of the Resource.
 6267        '''
 6268        self.name = name if name is not None else ''
 6269        '''
 6270         Unique human-readable name of the Resource.
 6271        '''
 6272        self.port = port if port is not None else 0
 6273        self.port_override = port_override if port_override is not None else 0
 6274        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 6275        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 6276        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6277        '''
 6278         ID of the secret store containing credentials for this resource, if any.
 6279        '''
 6280        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6281        '''
 6282         Tags is a map of key, value pairs.
 6283        '''
 6284
 6285    def __repr__(self):
 6286        return '<sdm.Kubernetes ' + \
 6287            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6288            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6289            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6290            'client_key: ' + repr(self.client_key) + ' ' +\
 6291            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6292            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6293            'healthy: ' + repr(self.healthy) + ' ' +\
 6294            'hostname: ' + repr(self.hostname) + ' ' +\
 6295            'id: ' + repr(self.id) + ' ' +\
 6296            'name: ' + repr(self.name) + ' ' +\
 6297            'port: ' + repr(self.port) + ' ' +\
 6298            'port_override: ' + repr(self.port_override) + ' ' +\
 6299            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 6300            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 6301            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6302            'tags: ' + repr(self.tags) + ' ' +\
 6303            '>'
 6304
 6305    def to_dict(self):
 6306        return {
 6307            'bind_interface': self.bind_interface,
 6308            'certificate_authority': self.certificate_authority,
 6309            'client_certificate': self.client_certificate,
 6310            'client_key': self.client_key,
 6311            'egress_filter': self.egress_filter,
 6312            'healthcheck_namespace': self.healthcheck_namespace,
 6313            'healthy': self.healthy,
 6314            'hostname': self.hostname,
 6315            'id': self.id,
 6316            'name': self.name,
 6317            'port': self.port,
 6318            'port_override': self.port_override,
 6319            'remote_identity_group_id': self.remote_identity_group_id,
 6320            'remote_identity_healthcheck_username':
 6321            self.remote_identity_healthcheck_username,
 6322            'secret_store_id': self.secret_store_id,
 6323            'tags': self.tags,
 6324        }
 6325
 6326    @classmethod
 6327    def from_dict(cls, d):
 6328        return cls(
 6329            bind_interface=d.get('bind_interface'),
 6330            certificate_authority=d.get('certificate_authority'),
 6331            client_certificate=d.get('client_certificate'),
 6332            client_key=d.get('client_key'),
 6333            egress_filter=d.get('egress_filter'),
 6334            healthcheck_namespace=d.get('healthcheck_namespace'),
 6335            healthy=d.get('healthy'),
 6336            hostname=d.get('hostname'),
 6337            id=d.get('id'),
 6338            name=d.get('name'),
 6339            port=d.get('port'),
 6340            port_override=d.get('port_override'),
 6341            remote_identity_group_id=d.get('remote_identity_group_id'),
 6342            remote_identity_healthcheck_username=d.get(
 6343                'remote_identity_healthcheck_username'),
 6344            secret_store_id=d.get('secret_store_id'),
 6345            tags=d.get('tags'),
 6346        )
 6347
 6348
 6349class KubernetesBasicAuth:
 6350    __slots__ = [
 6351        'bind_interface',
 6352        'egress_filter',
 6353        'healthcheck_namespace',
 6354        'healthy',
 6355        'hostname',
 6356        'id',
 6357        'name',
 6358        'password',
 6359        'port',
 6360        'port_override',
 6361        'secret_store_id',
 6362        'tags',
 6363        'username',
 6364    ]
 6365
 6366    def __init__(
 6367        self,
 6368        bind_interface=None,
 6369        egress_filter=None,
 6370        healthcheck_namespace=None,
 6371        healthy=None,
 6372        hostname=None,
 6373        id=None,
 6374        name=None,
 6375        password=None,
 6376        port=None,
 6377        port_override=None,
 6378        secret_store_id=None,
 6379        tags=None,
 6380        username=None,
 6381    ):
 6382        self.bind_interface = bind_interface if bind_interface is not None else ''
 6383        '''
 6384         Bind interface
 6385        '''
 6386        self.egress_filter = egress_filter if egress_filter is not None else ''
 6387        '''
 6388         A filter applied to the routing logic to pin datasource to nodes.
 6389        '''
 6390        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6391        '''
 6392         The path used to check the health of your connection.  Defaults to `default`.
 6393        '''
 6394        self.healthy = healthy if healthy is not None else False
 6395        '''
 6396         True if the datasource is reachable and the credentials are valid.
 6397        '''
 6398        self.hostname = hostname if hostname is not None else ''
 6399        self.id = id if id is not None else ''
 6400        '''
 6401         Unique identifier of the Resource.
 6402        '''
 6403        self.name = name if name is not None else ''
 6404        '''
 6405         Unique human-readable name of the Resource.
 6406        '''
 6407        self.password = password if password is not None else ''
 6408        self.port = port if port is not None else 0
 6409        self.port_override = port_override if port_override is not None else 0
 6410        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6411        '''
 6412         ID of the secret store containing credentials for this resource, if any.
 6413        '''
 6414        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6415        '''
 6416         Tags is a map of key, value pairs.
 6417        '''
 6418        self.username = username if username is not None else ''
 6419
 6420    def __repr__(self):
 6421        return '<sdm.KubernetesBasicAuth ' + \
 6422            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6423            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6424            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6425            'healthy: ' + repr(self.healthy) + ' ' +\
 6426            'hostname: ' + repr(self.hostname) + ' ' +\
 6427            'id: ' + repr(self.id) + ' ' +\
 6428            'name: ' + repr(self.name) + ' ' +\
 6429            'password: ' + repr(self.password) + ' ' +\
 6430            'port: ' + repr(self.port) + ' ' +\
 6431            'port_override: ' + repr(self.port_override) + ' ' +\
 6432            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6433            'tags: ' + repr(self.tags) + ' ' +\
 6434            'username: ' + repr(self.username) + ' ' +\
 6435            '>'
 6436
 6437    def to_dict(self):
 6438        return {
 6439            'bind_interface': self.bind_interface,
 6440            'egress_filter': self.egress_filter,
 6441            'healthcheck_namespace': self.healthcheck_namespace,
 6442            'healthy': self.healthy,
 6443            'hostname': self.hostname,
 6444            'id': self.id,
 6445            'name': self.name,
 6446            'password': self.password,
 6447            'port': self.port,
 6448            'port_override': self.port_override,
 6449            'secret_store_id': self.secret_store_id,
 6450            'tags': self.tags,
 6451            'username': self.username,
 6452        }
 6453
 6454    @classmethod
 6455    def from_dict(cls, d):
 6456        return cls(
 6457            bind_interface=d.get('bind_interface'),
 6458            egress_filter=d.get('egress_filter'),
 6459            healthcheck_namespace=d.get('healthcheck_namespace'),
 6460            healthy=d.get('healthy'),
 6461            hostname=d.get('hostname'),
 6462            id=d.get('id'),
 6463            name=d.get('name'),
 6464            password=d.get('password'),
 6465            port=d.get('port'),
 6466            port_override=d.get('port_override'),
 6467            secret_store_id=d.get('secret_store_id'),
 6468            tags=d.get('tags'),
 6469            username=d.get('username'),
 6470        )
 6471
 6472
 6473class KubernetesServiceAccount:
 6474    __slots__ = [
 6475        'bind_interface',
 6476        'egress_filter',
 6477        'healthcheck_namespace',
 6478        'healthy',
 6479        'hostname',
 6480        'id',
 6481        'name',
 6482        'port',
 6483        'port_override',
 6484        'remote_identity_group_id',
 6485        'remote_identity_healthcheck_username',
 6486        'secret_store_id',
 6487        'tags',
 6488        'token',
 6489    ]
 6490
 6491    def __init__(
 6492        self,
 6493        bind_interface=None,
 6494        egress_filter=None,
 6495        healthcheck_namespace=None,
 6496        healthy=None,
 6497        hostname=None,
 6498        id=None,
 6499        name=None,
 6500        port=None,
 6501        port_override=None,
 6502        remote_identity_group_id=None,
 6503        remote_identity_healthcheck_username=None,
 6504        secret_store_id=None,
 6505        tags=None,
 6506        token=None,
 6507    ):
 6508        self.bind_interface = bind_interface if bind_interface is not None else ''
 6509        '''
 6510         Bind interface
 6511        '''
 6512        self.egress_filter = egress_filter if egress_filter is not None else ''
 6513        '''
 6514         A filter applied to the routing logic to pin datasource to nodes.
 6515        '''
 6516        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6517        '''
 6518         The path used to check the health of your connection.  Defaults to `default`.
 6519        '''
 6520        self.healthy = healthy if healthy is not None else False
 6521        '''
 6522         True if the datasource is reachable and the credentials are valid.
 6523        '''
 6524        self.hostname = hostname if hostname is not None else ''
 6525        self.id = id if id is not None else ''
 6526        '''
 6527         Unique identifier of the Resource.
 6528        '''
 6529        self.name = name if name is not None else ''
 6530        '''
 6531         Unique human-readable name of the Resource.
 6532        '''
 6533        self.port = port if port is not None else 0
 6534        self.port_override = port_override if port_override is not None else 0
 6535        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 6536        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 6537        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6538        '''
 6539         ID of the secret store containing credentials for this resource, if any.
 6540        '''
 6541        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6542        '''
 6543         Tags is a map of key, value pairs.
 6544        '''
 6545        self.token = token if token is not None else ''
 6546
 6547    def __repr__(self):
 6548        return '<sdm.KubernetesServiceAccount ' + \
 6549            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6550            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6551            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6552            'healthy: ' + repr(self.healthy) + ' ' +\
 6553            'hostname: ' + repr(self.hostname) + ' ' +\
 6554            'id: ' + repr(self.id) + ' ' +\
 6555            'name: ' + repr(self.name) + ' ' +\
 6556            'port: ' + repr(self.port) + ' ' +\
 6557            'port_override: ' + repr(self.port_override) + ' ' +\
 6558            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 6559            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 6560            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6561            'tags: ' + repr(self.tags) + ' ' +\
 6562            'token: ' + repr(self.token) + ' ' +\
 6563            '>'
 6564
 6565    def to_dict(self):
 6566        return {
 6567            'bind_interface': self.bind_interface,
 6568            'egress_filter': self.egress_filter,
 6569            'healthcheck_namespace': self.healthcheck_namespace,
 6570            'healthy': self.healthy,
 6571            'hostname': self.hostname,
 6572            'id': self.id,
 6573            'name': self.name,
 6574            'port': self.port,
 6575            'port_override': self.port_override,
 6576            'remote_identity_group_id': self.remote_identity_group_id,
 6577            'remote_identity_healthcheck_username':
 6578            self.remote_identity_healthcheck_username,
 6579            'secret_store_id': self.secret_store_id,
 6580            'tags': self.tags,
 6581            'token': self.token,
 6582        }
 6583
 6584    @classmethod
 6585    def from_dict(cls, d):
 6586        return cls(
 6587            bind_interface=d.get('bind_interface'),
 6588            egress_filter=d.get('egress_filter'),
 6589            healthcheck_namespace=d.get('healthcheck_namespace'),
 6590            healthy=d.get('healthy'),
 6591            hostname=d.get('hostname'),
 6592            id=d.get('id'),
 6593            name=d.get('name'),
 6594            port=d.get('port'),
 6595            port_override=d.get('port_override'),
 6596            remote_identity_group_id=d.get('remote_identity_group_id'),
 6597            remote_identity_healthcheck_username=d.get(
 6598                'remote_identity_healthcheck_username'),
 6599            secret_store_id=d.get('secret_store_id'),
 6600            tags=d.get('tags'),
 6601            token=d.get('token'),
 6602        )
 6603
 6604
 6605class KubernetesServiceAccountUserImpersonation:
 6606    __slots__ = [
 6607        'bind_interface',
 6608        'egress_filter',
 6609        'healthcheck_namespace',
 6610        'healthy',
 6611        'hostname',
 6612        'id',
 6613        'name',
 6614        'port',
 6615        'port_override',
 6616        'secret_store_id',
 6617        'tags',
 6618        'token',
 6619    ]
 6620
 6621    def __init__(
 6622        self,
 6623        bind_interface=None,
 6624        egress_filter=None,
 6625        healthcheck_namespace=None,
 6626        healthy=None,
 6627        hostname=None,
 6628        id=None,
 6629        name=None,
 6630        port=None,
 6631        port_override=None,
 6632        secret_store_id=None,
 6633        tags=None,
 6634        token=None,
 6635    ):
 6636        self.bind_interface = bind_interface if bind_interface is not None else ''
 6637        '''
 6638         Bind interface
 6639        '''
 6640        self.egress_filter = egress_filter if egress_filter is not None else ''
 6641        '''
 6642         A filter applied to the routing logic to pin datasource to nodes.
 6643        '''
 6644        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6645        '''
 6646         The path used to check the health of your connection.  Defaults to `default`.
 6647        '''
 6648        self.healthy = healthy if healthy is not None else False
 6649        '''
 6650         True if the datasource is reachable and the credentials are valid.
 6651        '''
 6652        self.hostname = hostname if hostname is not None else ''
 6653        self.id = id if id is not None else ''
 6654        '''
 6655         Unique identifier of the Resource.
 6656        '''
 6657        self.name = name if name is not None else ''
 6658        '''
 6659         Unique human-readable name of the Resource.
 6660        '''
 6661        self.port = port if port is not None else 0
 6662        self.port_override = port_override if port_override is not None else 0
 6663        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6664        '''
 6665         ID of the secret store containing credentials for this resource, if any.
 6666        '''
 6667        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6668        '''
 6669         Tags is a map of key, value pairs.
 6670        '''
 6671        self.token = token if token is not None else ''
 6672
 6673    def __repr__(self):
 6674        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
 6675            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6676            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6677            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6678            'healthy: ' + repr(self.healthy) + ' ' +\
 6679            'hostname: ' + repr(self.hostname) + ' ' +\
 6680            'id: ' + repr(self.id) + ' ' +\
 6681            'name: ' + repr(self.name) + ' ' +\
 6682            'port: ' + repr(self.port) + ' ' +\
 6683            'port_override: ' + repr(self.port_override) + ' ' +\
 6684            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6685            'tags: ' + repr(self.tags) + ' ' +\
 6686            'token: ' + repr(self.token) + ' ' +\
 6687            '>'
 6688
 6689    def to_dict(self):
 6690        return {
 6691            'bind_interface': self.bind_interface,
 6692            'egress_filter': self.egress_filter,
 6693            'healthcheck_namespace': self.healthcheck_namespace,
 6694            'healthy': self.healthy,
 6695            'hostname': self.hostname,
 6696            'id': self.id,
 6697            'name': self.name,
 6698            'port': self.port,
 6699            'port_override': self.port_override,
 6700            'secret_store_id': self.secret_store_id,
 6701            'tags': self.tags,
 6702            'token': self.token,
 6703        }
 6704
 6705    @classmethod
 6706    def from_dict(cls, d):
 6707        return cls(
 6708            bind_interface=d.get('bind_interface'),
 6709            egress_filter=d.get('egress_filter'),
 6710            healthcheck_namespace=d.get('healthcheck_namespace'),
 6711            healthy=d.get('healthy'),
 6712            hostname=d.get('hostname'),
 6713            id=d.get('id'),
 6714            name=d.get('name'),
 6715            port=d.get('port'),
 6716            port_override=d.get('port_override'),
 6717            secret_store_id=d.get('secret_store_id'),
 6718            tags=d.get('tags'),
 6719            token=d.get('token'),
 6720        )
 6721
 6722
 6723class KubernetesUserImpersonation:
 6724    __slots__ = [
 6725        'bind_interface',
 6726        'certificate_authority',
 6727        'client_certificate',
 6728        'client_key',
 6729        'egress_filter',
 6730        'healthcheck_namespace',
 6731        'healthy',
 6732        'hostname',
 6733        'id',
 6734        'name',
 6735        'port',
 6736        'port_override',
 6737        'secret_store_id',
 6738        'tags',
 6739    ]
 6740
 6741    def __init__(
 6742        self,
 6743        bind_interface=None,
 6744        certificate_authority=None,
 6745        client_certificate=None,
 6746        client_key=None,
 6747        egress_filter=None,
 6748        healthcheck_namespace=None,
 6749        healthy=None,
 6750        hostname=None,
 6751        id=None,
 6752        name=None,
 6753        port=None,
 6754        port_override=None,
 6755        secret_store_id=None,
 6756        tags=None,
 6757    ):
 6758        self.bind_interface = bind_interface if bind_interface is not None else ''
 6759        '''
 6760         Bind interface
 6761        '''
 6762        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6763        self.client_certificate = client_certificate if client_certificate is not None else ''
 6764        self.client_key = client_key if client_key is not None else ''
 6765        self.egress_filter = egress_filter if egress_filter is not None else ''
 6766        '''
 6767         A filter applied to the routing logic to pin datasource to nodes.
 6768        '''
 6769        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6770        '''
 6771         The path used to check the health of your connection.  Defaults to `default`.
 6772        '''
 6773        self.healthy = healthy if healthy is not None else False
 6774        '''
 6775         True if the datasource is reachable and the credentials are valid.
 6776        '''
 6777        self.hostname = hostname if hostname is not None else ''
 6778        self.id = id if id is not None else ''
 6779        '''
 6780         Unique identifier of the Resource.
 6781        '''
 6782        self.name = name if name is not None else ''
 6783        '''
 6784         Unique human-readable name of the Resource.
 6785        '''
 6786        self.port = port if port is not None else 0
 6787        self.port_override = port_override if port_override is not None else 0
 6788        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6789        '''
 6790         ID of the secret store containing credentials for this resource, if any.
 6791        '''
 6792        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6793        '''
 6794         Tags is a map of key, value pairs.
 6795        '''
 6796
 6797    def __repr__(self):
 6798        return '<sdm.KubernetesUserImpersonation ' + \
 6799            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6800            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6801            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6802            'client_key: ' + repr(self.client_key) + ' ' +\
 6803            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6804            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6805            'healthy: ' + repr(self.healthy) + ' ' +\
 6806            'hostname: ' + repr(self.hostname) + ' ' +\
 6807            'id: ' + repr(self.id) + ' ' +\
 6808            'name: ' + repr(self.name) + ' ' +\
 6809            'port: ' + repr(self.port) + ' ' +\
 6810            'port_override: ' + repr(self.port_override) + ' ' +\
 6811            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6812            'tags: ' + repr(self.tags) + ' ' +\
 6813            '>'
 6814
 6815    def to_dict(self):
 6816        return {
 6817            'bind_interface': self.bind_interface,
 6818            'certificate_authority': self.certificate_authority,
 6819            'client_certificate': self.client_certificate,
 6820            'client_key': self.client_key,
 6821            'egress_filter': self.egress_filter,
 6822            'healthcheck_namespace': self.healthcheck_namespace,
 6823            'healthy': self.healthy,
 6824            'hostname': self.hostname,
 6825            'id': self.id,
 6826            'name': self.name,
 6827            'port': self.port,
 6828            'port_override': self.port_override,
 6829            'secret_store_id': self.secret_store_id,
 6830            'tags': self.tags,
 6831        }
 6832
 6833    @classmethod
 6834    def from_dict(cls, d):
 6835        return cls(
 6836            bind_interface=d.get('bind_interface'),
 6837            certificate_authority=d.get('certificate_authority'),
 6838            client_certificate=d.get('client_certificate'),
 6839            client_key=d.get('client_key'),
 6840            egress_filter=d.get('egress_filter'),
 6841            healthcheck_namespace=d.get('healthcheck_namespace'),
 6842            healthy=d.get('healthy'),
 6843            hostname=d.get('hostname'),
 6844            id=d.get('id'),
 6845            name=d.get('name'),
 6846            port=d.get('port'),
 6847            port_override=d.get('port_override'),
 6848            secret_store_id=d.get('secret_store_id'),
 6849            tags=d.get('tags'),
 6850        )
 6851
 6852
 6853class MTLSMysql:
 6854    '''
 6855    MTLSMysql is currently unstable, and its API may change, or it may be removed,
 6856    without a major version bump.
 6857    '''
 6858    __slots__ = [
 6859        'bind_interface',
 6860        'certificate_authority',
 6861        'client_certificate',
 6862        'client_key',
 6863        'database',
 6864        'egress_filter',
 6865        'healthy',
 6866        'hostname',
 6867        'id',
 6868        'name',
 6869        'password',
 6870        'port',
 6871        'port_override',
 6872        'secret_store_id',
 6873        'server_name',
 6874        'tags',
 6875        'username',
 6876    ]
 6877
 6878    def __init__(
 6879        self,
 6880        bind_interface=None,
 6881        certificate_authority=None,
 6882        client_certificate=None,
 6883        client_key=None,
 6884        database=None,
 6885        egress_filter=None,
 6886        healthy=None,
 6887        hostname=None,
 6888        id=None,
 6889        name=None,
 6890        password=None,
 6891        port=None,
 6892        port_override=None,
 6893        secret_store_id=None,
 6894        server_name=None,
 6895        tags=None,
 6896        username=None,
 6897    ):
 6898        self.bind_interface = bind_interface if bind_interface is not None else ''
 6899        '''
 6900         Bind interface
 6901        '''
 6902        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6903        self.client_certificate = client_certificate if client_certificate is not None else ''
 6904        self.client_key = client_key if client_key is not None else ''
 6905        self.database = database if database is not None else ''
 6906        self.egress_filter = egress_filter if egress_filter is not None else ''
 6907        '''
 6908         A filter applied to the routing logic to pin datasource to nodes.
 6909        '''
 6910        self.healthy = healthy if healthy is not None else False
 6911        '''
 6912         True if the datasource is reachable and the credentials are valid.
 6913        '''
 6914        self.hostname = hostname if hostname is not None else ''
 6915        self.id = id if id is not None else ''
 6916        '''
 6917         Unique identifier of the Resource.
 6918        '''
 6919        self.name = name if name is not None else ''
 6920        '''
 6921         Unique human-readable name of the Resource.
 6922        '''
 6923        self.password = password if password is not None else ''
 6924        self.port = port if port is not None else 0
 6925        self.port_override = port_override if port_override is not None else 0
 6926        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6927        '''
 6928         ID of the secret store containing credentials for this resource, if any.
 6929        '''
 6930        self.server_name = server_name if server_name is not None else ''
 6931        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6932        '''
 6933         Tags is a map of key, value pairs.
 6934        '''
 6935        self.username = username if username is not None else ''
 6936
 6937    def __repr__(self):
 6938        return '<sdm.MTLSMysql ' + \
 6939            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6940            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6941            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6942            'client_key: ' + repr(self.client_key) + ' ' +\
 6943            'database: ' + repr(self.database) + ' ' +\
 6944            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6945            'healthy: ' + repr(self.healthy) + ' ' +\
 6946            'hostname: ' + repr(self.hostname) + ' ' +\
 6947            'id: ' + repr(self.id) + ' ' +\
 6948            'name: ' + repr(self.name) + ' ' +\
 6949            'password: ' + repr(self.password) + ' ' +\
 6950            'port: ' + repr(self.port) + ' ' +\
 6951            'port_override: ' + repr(self.port_override) + ' ' +\
 6952            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6953            'server_name: ' + repr(self.server_name) + ' ' +\
 6954            'tags: ' + repr(self.tags) + ' ' +\
 6955            'username: ' + repr(self.username) + ' ' +\
 6956            '>'
 6957
 6958    def to_dict(self):
 6959        return {
 6960            'bind_interface': self.bind_interface,
 6961            'certificate_authority': self.certificate_authority,
 6962            'client_certificate': self.client_certificate,
 6963            'client_key': self.client_key,
 6964            'database': self.database,
 6965            'egress_filter': self.egress_filter,
 6966            'healthy': self.healthy,
 6967            'hostname': self.hostname,
 6968            'id': self.id,
 6969            'name': self.name,
 6970            'password': self.password,
 6971            'port': self.port,
 6972            'port_override': self.port_override,
 6973            'secret_store_id': self.secret_store_id,
 6974            'server_name': self.server_name,
 6975            'tags': self.tags,
 6976            'username': self.username,
 6977        }
 6978
 6979    @classmethod
 6980    def from_dict(cls, d):
 6981        return cls(
 6982            bind_interface=d.get('bind_interface'),
 6983            certificate_authority=d.get('certificate_authority'),
 6984            client_certificate=d.get('client_certificate'),
 6985            client_key=d.get('client_key'),
 6986            database=d.get('database'),
 6987            egress_filter=d.get('egress_filter'),
 6988            healthy=d.get('healthy'),
 6989            hostname=d.get('hostname'),
 6990            id=d.get('id'),
 6991            name=d.get('name'),
 6992            password=d.get('password'),
 6993            port=d.get('port'),
 6994            port_override=d.get('port_override'),
 6995            secret_store_id=d.get('secret_store_id'),
 6996            server_name=d.get('server_name'),
 6997            tags=d.get('tags'),
 6998            username=d.get('username'),
 6999        )
 7000
 7001
 7002class MTLSPostgres:
 7003    __slots__ = [
 7004        'bind_interface',
 7005        'certificate_authority',
 7006        'client_certificate',
 7007        'client_key',
 7008        'database',
 7009        'egress_filter',
 7010        'healthy',
 7011        'hostname',
 7012        'id',
 7013        'name',
 7014        'override_database',
 7015        'password',
 7016        'port',
 7017        'port_override',
 7018        'secret_store_id',
 7019        'server_name',
 7020        'tags',
 7021        'username',
 7022    ]
 7023
 7024    def __init__(
 7025        self,
 7026        bind_interface=None,
 7027        certificate_authority=None,
 7028        client_certificate=None,
 7029        client_key=None,
 7030        database=None,
 7031        egress_filter=None,
 7032        healthy=None,
 7033        hostname=None,
 7034        id=None,
 7035        name=None,
 7036        override_database=None,
 7037        password=None,
 7038        port=None,
 7039        port_override=None,
 7040        secret_store_id=None,
 7041        server_name=None,
 7042        tags=None,
 7043        username=None,
 7044    ):
 7045        self.bind_interface = bind_interface if bind_interface is not None else ''
 7046        '''
 7047         Bind interface
 7048        '''
 7049        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 7050        self.client_certificate = client_certificate if client_certificate is not None else ''
 7051        self.client_key = client_key if client_key is not None else ''
 7052        self.database = database if database is not None else ''
 7053        self.egress_filter = egress_filter if egress_filter is not None else ''
 7054        '''
 7055         A filter applied to the routing logic to pin datasource to nodes.
 7056        '''
 7057        self.healthy = healthy if healthy is not None else False
 7058        '''
 7059         True if the datasource is reachable and the credentials are valid.
 7060        '''
 7061        self.hostname = hostname if hostname is not None else ''
 7062        self.id = id if id is not None else ''
 7063        '''
 7064         Unique identifier of the Resource.
 7065        '''
 7066        self.name = name if name is not None else ''
 7067        '''
 7068         Unique human-readable name of the Resource.
 7069        '''
 7070        self.override_database = override_database if override_database is not None else False
 7071        self.password = password if password is not None else ''
 7072        self.port = port if port is not None else 0
 7073        self.port_override = port_override if port_override is not None else 0
 7074        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7075        '''
 7076         ID of the secret store containing credentials for this resource, if any.
 7077        '''
 7078        self.server_name = server_name if server_name is not None else ''
 7079        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7080        '''
 7081         Tags is a map of key, value pairs.
 7082        '''
 7083        self.username = username if username is not None else ''
 7084
 7085    def __repr__(self):
 7086        return '<sdm.MTLSPostgres ' + \
 7087            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7088            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 7089            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 7090            'client_key: ' + repr(self.client_key) + ' ' +\
 7091            'database: ' + repr(self.database) + ' ' +\
 7092            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7093            'healthy: ' + repr(self.healthy) + ' ' +\
 7094            'hostname: ' + repr(self.hostname) + ' ' +\
 7095            'id: ' + repr(self.id) + ' ' +\
 7096            'name: ' + repr(self.name) + ' ' +\
 7097            'override_database: ' + repr(self.override_database) + ' ' +\
 7098            'password: ' + repr(self.password) + ' ' +\
 7099            'port: ' + repr(self.port) + ' ' +\
 7100            'port_override: ' + repr(self.port_override) + ' ' +\
 7101            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7102            'server_name: ' + repr(self.server_name) + ' ' +\
 7103            'tags: ' + repr(self.tags) + ' ' +\
 7104            'username: ' + repr(self.username) + ' ' +\
 7105            '>'
 7106
 7107    def to_dict(self):
 7108        return {
 7109            'bind_interface': self.bind_interface,
 7110            'certificate_authority': self.certificate_authority,
 7111            'client_certificate': self.client_certificate,
 7112            'client_key': self.client_key,
 7113            'database': self.database,
 7114            'egress_filter': self.egress_filter,
 7115            'healthy': self.healthy,
 7116            'hostname': self.hostname,
 7117            'id': self.id,
 7118            'name': self.name,
 7119            'override_database': self.override_database,
 7120            'password': self.password,
 7121            'port': self.port,
 7122            'port_override': self.port_override,
 7123            'secret_store_id': self.secret_store_id,
 7124            'server_name': self.server_name,
 7125            'tags': self.tags,
 7126            'username': self.username,
 7127        }
 7128
 7129    @classmethod
 7130    def from_dict(cls, d):
 7131        return cls(
 7132            bind_interface=d.get('bind_interface'),
 7133            certificate_authority=d.get('certificate_authority'),
 7134            client_certificate=d.get('client_certificate'),
 7135            client_key=d.get('client_key'),
 7136            database=d.get('database'),
 7137            egress_filter=d.get('egress_filter'),
 7138            healthy=d.get('healthy'),
 7139            hostname=d.get('hostname'),
 7140            id=d.get('id'),
 7141            name=d.get('name'),
 7142            override_database=d.get('override_database'),
 7143            password=d.get('password'),
 7144            port=d.get('port'),
 7145            port_override=d.get('port_override'),
 7146            secret_store_id=d.get('secret_store_id'),
 7147            server_name=d.get('server_name'),
 7148            tags=d.get('tags'),
 7149            username=d.get('username'),
 7150        )
 7151
 7152
 7153class Maria:
 7154    __slots__ = [
 7155        'bind_interface',
 7156        'database',
 7157        'egress_filter',
 7158        'healthy',
 7159        'hostname',
 7160        'id',
 7161        'name',
 7162        'password',
 7163        'port',
 7164        'port_override',
 7165        'secret_store_id',
 7166        'tags',
 7167        'username',
 7168    ]
 7169
 7170    def __init__(
 7171        self,
 7172        bind_interface=None,
 7173        database=None,
 7174        egress_filter=None,
 7175        healthy=None,
 7176        hostname=None,
 7177        id=None,
 7178        name=None,
 7179        password=None,
 7180        port=None,
 7181        port_override=None,
 7182        secret_store_id=None,
 7183        tags=None,
 7184        username=None,
 7185    ):
 7186        self.bind_interface = bind_interface if bind_interface is not None else ''
 7187        '''
 7188         Bind interface
 7189        '''
 7190        self.database = database if database is not None else ''
 7191        self.egress_filter = egress_filter if egress_filter is not None else ''
 7192        '''
 7193         A filter applied to the routing logic to pin datasource to nodes.
 7194        '''
 7195        self.healthy = healthy if healthy is not None else False
 7196        '''
 7197         True if the datasource is reachable and the credentials are valid.
 7198        '''
 7199        self.hostname = hostname if hostname is not None else ''
 7200        self.id = id if id is not None else ''
 7201        '''
 7202         Unique identifier of the Resource.
 7203        '''
 7204        self.name = name if name is not None else ''
 7205        '''
 7206         Unique human-readable name of the Resource.
 7207        '''
 7208        self.password = password if password is not None else ''
 7209        self.port = port if port is not None else 0
 7210        self.port_override = port_override if port_override is not None else 0
 7211        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7212        '''
 7213         ID of the secret store containing credentials for this resource, if any.
 7214        '''
 7215        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7216        '''
 7217         Tags is a map of key, value pairs.
 7218        '''
 7219        self.username = username if username is not None else ''
 7220
 7221    def __repr__(self):
 7222        return '<sdm.Maria ' + \
 7223            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7224            'database: ' + repr(self.database) + ' ' +\
 7225            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7226            'healthy: ' + repr(self.healthy) + ' ' +\
 7227            'hostname: ' + repr(self.hostname) + ' ' +\
 7228            'id: ' + repr(self.id) + ' ' +\
 7229            'name: ' + repr(self.name) + ' ' +\
 7230            'password: ' + repr(self.password) + ' ' +\
 7231            'port: ' + repr(self.port) + ' ' +\
 7232            'port_override: ' + repr(self.port_override) + ' ' +\
 7233            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7234            'tags: ' + repr(self.tags) + ' ' +\
 7235            'username: ' + repr(self.username) + ' ' +\
 7236            '>'
 7237
 7238    def to_dict(self):
 7239        return {
 7240            'bind_interface': self.bind_interface,
 7241            'database': self.database,
 7242            'egress_filter': self.egress_filter,
 7243            'healthy': self.healthy,
 7244            'hostname': self.hostname,
 7245            'id': self.id,
 7246            'name': self.name,
 7247            'password': self.password,
 7248            'port': self.port,
 7249            'port_override': self.port_override,
 7250            'secret_store_id': self.secret_store_id,
 7251            'tags': self.tags,
 7252            'username': self.username,
 7253        }
 7254
 7255    @classmethod
 7256    def from_dict(cls, d):
 7257        return cls(
 7258            bind_interface=d.get('bind_interface'),
 7259            database=d.get('database'),
 7260            egress_filter=d.get('egress_filter'),
 7261            healthy=d.get('healthy'),
 7262            hostname=d.get('hostname'),
 7263            id=d.get('id'),
 7264            name=d.get('name'),
 7265            password=d.get('password'),
 7266            port=d.get('port'),
 7267            port_override=d.get('port_override'),
 7268            secret_store_id=d.get('secret_store_id'),
 7269            tags=d.get('tags'),
 7270            username=d.get('username'),
 7271        )
 7272
 7273
 7274class Memcached:
 7275    __slots__ = [
 7276        'bind_interface',
 7277        'egress_filter',
 7278        'healthy',
 7279        'hostname',
 7280        'id',
 7281        'name',
 7282        'port',
 7283        'port_override',
 7284        'secret_store_id',
 7285        'tags',
 7286    ]
 7287
 7288    def __init__(
 7289        self,
 7290        bind_interface=None,
 7291        egress_filter=None,
 7292        healthy=None,
 7293        hostname=None,
 7294        id=None,
 7295        name=None,
 7296        port=None,
 7297        port_override=None,
 7298        secret_store_id=None,
 7299        tags=None,
 7300    ):
 7301        self.bind_interface = bind_interface if bind_interface is not None else ''
 7302        '''
 7303         Bind interface
 7304        '''
 7305        self.egress_filter = egress_filter if egress_filter is not None else ''
 7306        '''
 7307         A filter applied to the routing logic to pin datasource to nodes.
 7308        '''
 7309        self.healthy = healthy if healthy is not None else False
 7310        '''
 7311         True if the datasource is reachable and the credentials are valid.
 7312        '''
 7313        self.hostname = hostname if hostname is not None else ''
 7314        self.id = id if id is not None else ''
 7315        '''
 7316         Unique identifier of the Resource.
 7317        '''
 7318        self.name = name if name is not None else ''
 7319        '''
 7320         Unique human-readable name of the Resource.
 7321        '''
 7322        self.port = port if port is not None else 0
 7323        self.port_override = port_override if port_override is not None else 0
 7324        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7325        '''
 7326         ID of the secret store containing credentials for this resource, if any.
 7327        '''
 7328        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7329        '''
 7330         Tags is a map of key, value pairs.
 7331        '''
 7332
 7333    def __repr__(self):
 7334        return '<sdm.Memcached ' + \
 7335            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7336            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7337            'healthy: ' + repr(self.healthy) + ' ' +\
 7338            'hostname: ' + repr(self.hostname) + ' ' +\
 7339            'id: ' + repr(self.id) + ' ' +\
 7340            'name: ' + repr(self.name) + ' ' +\
 7341            'port: ' + repr(self.port) + ' ' +\
 7342            'port_override: ' + repr(self.port_override) + ' ' +\
 7343            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7344            'tags: ' + repr(self.tags) + ' ' +\
 7345            '>'
 7346
 7347    def to_dict(self):
 7348        return {
 7349            'bind_interface': self.bind_interface,
 7350            'egress_filter': self.egress_filter,
 7351            'healthy': self.healthy,
 7352            'hostname': self.hostname,
 7353            'id': self.id,
 7354            'name': self.name,
 7355            'port': self.port,
 7356            'port_override': self.port_override,
 7357            'secret_store_id': self.secret_store_id,
 7358            'tags': self.tags,
 7359        }
 7360
 7361    @classmethod
 7362    def from_dict(cls, d):
 7363        return cls(
 7364            bind_interface=d.get('bind_interface'),
 7365            egress_filter=d.get('egress_filter'),
 7366            healthy=d.get('healthy'),
 7367            hostname=d.get('hostname'),
 7368            id=d.get('id'),
 7369            name=d.get('name'),
 7370            port=d.get('port'),
 7371            port_override=d.get('port_override'),
 7372            secret_store_id=d.get('secret_store_id'),
 7373            tags=d.get('tags'),
 7374        )
 7375
 7376
 7377class Memsql:
 7378    __slots__ = [
 7379        'bind_interface',
 7380        'database',
 7381        'egress_filter',
 7382        'healthy',
 7383        'hostname',
 7384        'id',
 7385        'name',
 7386        'password',
 7387        'port',
 7388        'port_override',
 7389        'secret_store_id',
 7390        'tags',
 7391        'username',
 7392    ]
 7393
 7394    def __init__(
 7395        self,
 7396        bind_interface=None,
 7397        database=None,
 7398        egress_filter=None,
 7399        healthy=None,
 7400        hostname=None,
 7401        id=None,
 7402        name=None,
 7403        password=None,
 7404        port=None,
 7405        port_override=None,
 7406        secret_store_id=None,
 7407        tags=None,
 7408        username=None,
 7409    ):
 7410        self.bind_interface = bind_interface if bind_interface is not None else ''
 7411        '''
 7412         Bind interface
 7413        '''
 7414        self.database = database if database is not None else ''
 7415        self.egress_filter = egress_filter if egress_filter is not None else ''
 7416        '''
 7417         A filter applied to the routing logic to pin datasource to nodes.
 7418        '''
 7419        self.healthy = healthy if healthy is not None else False
 7420        '''
 7421         True if the datasource is reachable and the credentials are valid.
 7422        '''
 7423        self.hostname = hostname if hostname is not None else ''
 7424        self.id = id if id is not None else ''
 7425        '''
 7426         Unique identifier of the Resource.
 7427        '''
 7428        self.name = name if name is not None else ''
 7429        '''
 7430         Unique human-readable name of the Resource.
 7431        '''
 7432        self.password = password if password is not None else ''
 7433        self.port = port if port is not None else 0
 7434        self.port_override = port_override if port_override is not None else 0
 7435        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7436        '''
 7437         ID of the secret store containing credentials for this resource, if any.
 7438        '''
 7439        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7440        '''
 7441         Tags is a map of key, value pairs.
 7442        '''
 7443        self.username = username if username is not None else ''
 7444
 7445    def __repr__(self):
 7446        return '<sdm.Memsql ' + \
 7447            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7448            'database: ' + repr(self.database) + ' ' +\
 7449            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7450            'healthy: ' + repr(self.healthy) + ' ' +\
 7451            'hostname: ' + repr(self.hostname) + ' ' +\
 7452            'id: ' + repr(self.id) + ' ' +\
 7453            'name: ' + repr(self.name) + ' ' +\
 7454            'password: ' + repr(self.password) + ' ' +\
 7455            'port: ' + repr(self.port) + ' ' +\
 7456            'port_override: ' + repr(self.port_override) + ' ' +\
 7457            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7458            'tags: ' + repr(self.tags) + ' ' +\
 7459            'username: ' + repr(self.username) + ' ' +\
 7460            '>'
 7461
 7462    def to_dict(self):
 7463        return {
 7464            'bind_interface': self.bind_interface,
 7465            'database': self.database,
 7466            'egress_filter': self.egress_filter,
 7467            'healthy': self.healthy,
 7468            'hostname': self.hostname,
 7469            'id': self.id,
 7470            'name': self.name,
 7471            'password': self.password,
 7472            'port': self.port,
 7473            'port_override': self.port_override,
 7474            'secret_store_id': self.secret_store_id,
 7475            'tags': self.tags,
 7476            'username': self.username,
 7477        }
 7478
 7479    @classmethod
 7480    def from_dict(cls, d):
 7481        return cls(
 7482            bind_interface=d.get('bind_interface'),
 7483            database=d.get('database'),
 7484            egress_filter=d.get('egress_filter'),
 7485            healthy=d.get('healthy'),
 7486            hostname=d.get('hostname'),
 7487            id=d.get('id'),
 7488            name=d.get('name'),
 7489            password=d.get('password'),
 7490            port=d.get('port'),
 7491            port_override=d.get('port_override'),
 7492            secret_store_id=d.get('secret_store_id'),
 7493            tags=d.get('tags'),
 7494            username=d.get('username'),
 7495        )
 7496
 7497
 7498class MongoHost:
 7499    '''
 7500    MongoHost is currently unstable, and its API may change, or it may be removed,
 7501    without a major version bump.
 7502    '''
 7503    __slots__ = [
 7504        'auth_database',
 7505        'bind_interface',
 7506        'egress_filter',
 7507        'healthy',
 7508        'hostname',
 7509        'id',
 7510        'name',
 7511        'password',
 7512        'port',
 7513        'port_override',
 7514        'secret_store_id',
 7515        'tags',
 7516        'tls_required',
 7517        'username',
 7518    ]
 7519
 7520    def __init__(
 7521        self,
 7522        auth_database=None,
 7523        bind_interface=None,
 7524        egress_filter=None,
 7525        healthy=None,
 7526        hostname=None,
 7527        id=None,
 7528        name=None,
 7529        password=None,
 7530        port=None,
 7531        port_override=None,
 7532        secret_store_id=None,
 7533        tags=None,
 7534        tls_required=None,
 7535        username=None,
 7536    ):
 7537        self.auth_database = auth_database if auth_database is not None else ''
 7538        self.bind_interface = bind_interface if bind_interface is not None else ''
 7539        '''
 7540         Bind interface
 7541        '''
 7542        self.egress_filter = egress_filter if egress_filter is not None else ''
 7543        '''
 7544         A filter applied to the routing logic to pin datasource to nodes.
 7545        '''
 7546        self.healthy = healthy if healthy is not None else False
 7547        '''
 7548         True if the datasource is reachable and the credentials are valid.
 7549        '''
 7550        self.hostname = hostname if hostname is not None else ''
 7551        self.id = id if id is not None else ''
 7552        '''
 7553         Unique identifier of the Resource.
 7554        '''
 7555        self.name = name if name is not None else ''
 7556        '''
 7557         Unique human-readable name of the Resource.
 7558        '''
 7559        self.password = password if password is not None else ''
 7560        self.port = port if port is not None else 0
 7561        self.port_override = port_override if port_override is not None else 0
 7562        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7563        '''
 7564         ID of the secret store containing credentials for this resource, if any.
 7565        '''
 7566        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7567        '''
 7568         Tags is a map of key, value pairs.
 7569        '''
 7570        self.tls_required = tls_required if tls_required is not None else False
 7571        self.username = username if username is not None else ''
 7572
 7573    def __repr__(self):
 7574        return '<sdm.MongoHost ' + \
 7575            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7576            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7577            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7578            'healthy: ' + repr(self.healthy) + ' ' +\
 7579            'hostname: ' + repr(self.hostname) + ' ' +\
 7580            'id: ' + repr(self.id) + ' ' +\
 7581            'name: ' + repr(self.name) + ' ' +\
 7582            'password: ' + repr(self.password) + ' ' +\
 7583            'port: ' + repr(self.port) + ' ' +\
 7584            'port_override: ' + repr(self.port_override) + ' ' +\
 7585            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7586            'tags: ' + repr(self.tags) + ' ' +\
 7587            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7588            'username: ' + repr(self.username) + ' ' +\
 7589            '>'
 7590
 7591    def to_dict(self):
 7592        return {
 7593            'auth_database': self.auth_database,
 7594            'bind_interface': self.bind_interface,
 7595            'egress_filter': self.egress_filter,
 7596            'healthy': self.healthy,
 7597            'hostname': self.hostname,
 7598            'id': self.id,
 7599            'name': self.name,
 7600            'password': self.password,
 7601            'port': self.port,
 7602            'port_override': self.port_override,
 7603            'secret_store_id': self.secret_store_id,
 7604            'tags': self.tags,
 7605            'tls_required': self.tls_required,
 7606            'username': self.username,
 7607        }
 7608
 7609    @classmethod
 7610    def from_dict(cls, d):
 7611        return cls(
 7612            auth_database=d.get('auth_database'),
 7613            bind_interface=d.get('bind_interface'),
 7614            egress_filter=d.get('egress_filter'),
 7615            healthy=d.get('healthy'),
 7616            hostname=d.get('hostname'),
 7617            id=d.get('id'),
 7618            name=d.get('name'),
 7619            password=d.get('password'),
 7620            port=d.get('port'),
 7621            port_override=d.get('port_override'),
 7622            secret_store_id=d.get('secret_store_id'),
 7623            tags=d.get('tags'),
 7624            tls_required=d.get('tls_required'),
 7625            username=d.get('username'),
 7626        )
 7627
 7628
 7629class MongoLegacyHost:
 7630    __slots__ = [
 7631        'auth_database',
 7632        'bind_interface',
 7633        'egress_filter',
 7634        'healthy',
 7635        'hostname',
 7636        'id',
 7637        'name',
 7638        'password',
 7639        'port',
 7640        'port_override',
 7641        'replica_set',
 7642        'secret_store_id',
 7643        'tags',
 7644        'tls_required',
 7645        'username',
 7646    ]
 7647
 7648    def __init__(
 7649        self,
 7650        auth_database=None,
 7651        bind_interface=None,
 7652        egress_filter=None,
 7653        healthy=None,
 7654        hostname=None,
 7655        id=None,
 7656        name=None,
 7657        password=None,
 7658        port=None,
 7659        port_override=None,
 7660        replica_set=None,
 7661        secret_store_id=None,
 7662        tags=None,
 7663        tls_required=None,
 7664        username=None,
 7665    ):
 7666        self.auth_database = auth_database if auth_database is not None else ''
 7667        self.bind_interface = bind_interface if bind_interface is not None else ''
 7668        '''
 7669         Bind interface
 7670        '''
 7671        self.egress_filter = egress_filter if egress_filter is not None else ''
 7672        '''
 7673         A filter applied to the routing logic to pin datasource to nodes.
 7674        '''
 7675        self.healthy = healthy if healthy is not None else False
 7676        '''
 7677         True if the datasource is reachable and the credentials are valid.
 7678        '''
 7679        self.hostname = hostname if hostname is not None else ''
 7680        self.id = id if id is not None else ''
 7681        '''
 7682         Unique identifier of the Resource.
 7683        '''
 7684        self.name = name if name is not None else ''
 7685        '''
 7686         Unique human-readable name of the Resource.
 7687        '''
 7688        self.password = password if password is not None else ''
 7689        self.port = port if port is not None else 0
 7690        self.port_override = port_override if port_override is not None else 0
 7691        self.replica_set = replica_set if replica_set is not None else ''
 7692        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7693        '''
 7694         ID of the secret store containing credentials for this resource, if any.
 7695        '''
 7696        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7697        '''
 7698         Tags is a map of key, value pairs.
 7699        '''
 7700        self.tls_required = tls_required if tls_required is not None else False
 7701        self.username = username if username is not None else ''
 7702
 7703    def __repr__(self):
 7704        return '<sdm.MongoLegacyHost ' + \
 7705            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7706            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7707            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7708            'healthy: ' + repr(self.healthy) + ' ' +\
 7709            'hostname: ' + repr(self.hostname) + ' ' +\
 7710            'id: ' + repr(self.id) + ' ' +\
 7711            'name: ' + repr(self.name) + ' ' +\
 7712            'password: ' + repr(self.password) + ' ' +\
 7713            'port: ' + repr(self.port) + ' ' +\
 7714            'port_override: ' + repr(self.port_override) + ' ' +\
 7715            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7716            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7717            'tags: ' + repr(self.tags) + ' ' +\
 7718            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7719            'username: ' + repr(self.username) + ' ' +\
 7720            '>'
 7721
 7722    def to_dict(self):
 7723        return {
 7724            'auth_database': self.auth_database,
 7725            'bind_interface': self.bind_interface,
 7726            'egress_filter': self.egress_filter,
 7727            'healthy': self.healthy,
 7728            'hostname': self.hostname,
 7729            'id': self.id,
 7730            'name': self.name,
 7731            'password': self.password,
 7732            'port': self.port,
 7733            'port_override': self.port_override,
 7734            'replica_set': self.replica_set,
 7735            'secret_store_id': self.secret_store_id,
 7736            'tags': self.tags,
 7737            'tls_required': self.tls_required,
 7738            'username': self.username,
 7739        }
 7740
 7741    @classmethod
 7742    def from_dict(cls, d):
 7743        return cls(
 7744            auth_database=d.get('auth_database'),
 7745            bind_interface=d.get('bind_interface'),
 7746            egress_filter=d.get('egress_filter'),
 7747            healthy=d.get('healthy'),
 7748            hostname=d.get('hostname'),
 7749            id=d.get('id'),
 7750            name=d.get('name'),
 7751            password=d.get('password'),
 7752            port=d.get('port'),
 7753            port_override=d.get('port_override'),
 7754            replica_set=d.get('replica_set'),
 7755            secret_store_id=d.get('secret_store_id'),
 7756            tags=d.get('tags'),
 7757            tls_required=d.get('tls_required'),
 7758            username=d.get('username'),
 7759        )
 7760
 7761
 7762class MongoLegacyReplicaset:
 7763    __slots__ = [
 7764        'auth_database',
 7765        'bind_interface',
 7766        'connect_to_replica',
 7767        'egress_filter',
 7768        'healthy',
 7769        'hostname',
 7770        'id',
 7771        'name',
 7772        'password',
 7773        'port',
 7774        'port_override',
 7775        'replica_set',
 7776        'secret_store_id',
 7777        'tags',
 7778        'tls_required',
 7779        'username',
 7780    ]
 7781
 7782    def __init__(
 7783        self,
 7784        auth_database=None,
 7785        bind_interface=None,
 7786        connect_to_replica=None,
 7787        egress_filter=None,
 7788        healthy=None,
 7789        hostname=None,
 7790        id=None,
 7791        name=None,
 7792        password=None,
 7793        port=None,
 7794        port_override=None,
 7795        replica_set=None,
 7796        secret_store_id=None,
 7797        tags=None,
 7798        tls_required=None,
 7799        username=None,
 7800    ):
 7801        self.auth_database = auth_database if auth_database is not None else ''
 7802        self.bind_interface = bind_interface if bind_interface is not None else ''
 7803        '''
 7804         Bind interface
 7805        '''
 7806        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 7807        self.egress_filter = egress_filter if egress_filter is not None else ''
 7808        '''
 7809         A filter applied to the routing logic to pin datasource to nodes.
 7810        '''
 7811        self.healthy = healthy if healthy is not None else False
 7812        '''
 7813         True if the datasource is reachable and the credentials are valid.
 7814        '''
 7815        self.hostname = hostname if hostname is not None else ''
 7816        self.id = id if id is not None else ''
 7817        '''
 7818         Unique identifier of the Resource.
 7819        '''
 7820        self.name = name if name is not None else ''
 7821        '''
 7822         Unique human-readable name of the Resource.
 7823        '''
 7824        self.password = password if password is not None else ''
 7825        self.port = port if port is not None else 0
 7826        self.port_override = port_override if port_override is not None else 0
 7827        self.replica_set = replica_set if replica_set is not None else ''
 7828        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7829        '''
 7830         ID of the secret store containing credentials for this resource, if any.
 7831        '''
 7832        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7833        '''
 7834         Tags is a map of key, value pairs.
 7835        '''
 7836        self.tls_required = tls_required if tls_required is not None else False
 7837        self.username = username if username is not None else ''
 7838
 7839    def __repr__(self):
 7840        return '<sdm.MongoLegacyReplicaset ' + \
 7841            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7842            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7843            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 7844            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7845            'healthy: ' + repr(self.healthy) + ' ' +\
 7846            'hostname: ' + repr(self.hostname) + ' ' +\
 7847            'id: ' + repr(self.id) + ' ' +\
 7848            'name: ' + repr(self.name) + ' ' +\
 7849            'password: ' + repr(self.password) + ' ' +\
 7850            'port: ' + repr(self.port) + ' ' +\
 7851            'port_override: ' + repr(self.port_override) + ' ' +\
 7852            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7853            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7854            'tags: ' + repr(self.tags) + ' ' +\
 7855            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7856            'username: ' + repr(self.username) + ' ' +\
 7857            '>'
 7858
 7859    def to_dict(self):
 7860        return {
 7861            'auth_database': self.auth_database,
 7862            'bind_interface': self.bind_interface,
 7863            'connect_to_replica': self.connect_to_replica,
 7864            'egress_filter': self.egress_filter,
 7865            'healthy': self.healthy,
 7866            'hostname': self.hostname,
 7867            'id': self.id,
 7868            'name': self.name,
 7869            'password': self.password,
 7870            'port': self.port,
 7871            'port_override': self.port_override,
 7872            'replica_set': self.replica_set,
 7873            'secret_store_id': self.secret_store_id,
 7874            'tags': self.tags,
 7875            'tls_required': self.tls_required,
 7876            'username': self.username,
 7877        }
 7878
 7879    @classmethod
 7880    def from_dict(cls, d):
 7881        return cls(
 7882            auth_database=d.get('auth_database'),
 7883            bind_interface=d.get('bind_interface'),
 7884            connect_to_replica=d.get('connect_to_replica'),
 7885            egress_filter=d.get('egress_filter'),
 7886            healthy=d.get('healthy'),
 7887            hostname=d.get('hostname'),
 7888            id=d.get('id'),
 7889            name=d.get('name'),
 7890            password=d.get('password'),
 7891            port=d.get('port'),
 7892            port_override=d.get('port_override'),
 7893            replica_set=d.get('replica_set'),
 7894            secret_store_id=d.get('secret_store_id'),
 7895            tags=d.get('tags'),
 7896            tls_required=d.get('tls_required'),
 7897            username=d.get('username'),
 7898        )
 7899
 7900
 7901class MongoReplicaSet:
 7902    '''
 7903    MongoReplicaSet is currently unstable, and its API may change, or it may be removed,
 7904    without a major version bump.
 7905    '''
 7906    __slots__ = [
 7907        'auth_database',
 7908        'bind_interface',
 7909        'connect_to_replica',
 7910        'egress_filter',
 7911        'healthy',
 7912        'hostname',
 7913        'id',
 7914        'name',
 7915        'password',
 7916        'port',
 7917        'port_override',
 7918        'replica_set',
 7919        'secret_store_id',
 7920        'tags',
 7921        'tls_required',
 7922        'username',
 7923    ]
 7924
 7925    def __init__(
 7926        self,
 7927        auth_database=None,
 7928        bind_interface=None,
 7929        connect_to_replica=None,
 7930        egress_filter=None,
 7931        healthy=None,
 7932        hostname=None,
 7933        id=None,
 7934        name=None,
 7935        password=None,
 7936        port=None,
 7937        port_override=None,
 7938        replica_set=None,
 7939        secret_store_id=None,
 7940        tags=None,
 7941        tls_required=None,
 7942        username=None,
 7943    ):
 7944        self.auth_database = auth_database if auth_database is not None else ''
 7945        self.bind_interface = bind_interface if bind_interface is not None else ''
 7946        '''
 7947         Bind interface
 7948        '''
 7949        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 7950        self.egress_filter = egress_filter if egress_filter is not None else ''
 7951        '''
 7952         A filter applied to the routing logic to pin datasource to nodes.
 7953        '''
 7954        self.healthy = healthy if healthy is not None else False
 7955        '''
 7956         True if the datasource is reachable and the credentials are valid.
 7957        '''
 7958        self.hostname = hostname if hostname is not None else ''
 7959        self.id = id if id is not None else ''
 7960        '''
 7961         Unique identifier of the Resource.
 7962        '''
 7963        self.name = name if name is not None else ''
 7964        '''
 7965         Unique human-readable name of the Resource.
 7966        '''
 7967        self.password = password if password is not None else ''
 7968        self.port = port if port is not None else 0
 7969        self.port_override = port_override if port_override is not None else 0
 7970        self.replica_set = replica_set if replica_set is not None else ''
 7971        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7972        '''
 7973         ID of the secret store containing credentials for this resource, if any.
 7974        '''
 7975        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7976        '''
 7977         Tags is a map of key, value pairs.
 7978        '''
 7979        self.tls_required = tls_required if tls_required is not None else False
 7980        self.username = username if username is not None else ''
 7981
 7982    def __repr__(self):
 7983        return '<sdm.MongoReplicaSet ' + \
 7984            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7985            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7986            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 7987            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7988            'healthy: ' + repr(self.healthy) + ' ' +\
 7989            'hostname: ' + repr(self.hostname) + ' ' +\
 7990            'id: ' + repr(self.id) + ' ' +\
 7991            'name: ' + repr(self.name) + ' ' +\
 7992            'password: ' + repr(self.password) + ' ' +\
 7993            'port: ' + repr(self.port) + ' ' +\
 7994            'port_override: ' + repr(self.port_override) + ' ' +\
 7995            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7996            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7997            'tags: ' + repr(self.tags) + ' ' +\
 7998            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7999            'username: ' + repr(self.username) + ' ' +\
 8000            '>'
 8001
 8002    def to_dict(self):
 8003        return {
 8004            'auth_database': self.auth_database,
 8005            'bind_interface': self.bind_interface,
 8006            'connect_to_replica': self.connect_to_replica,
 8007            'egress_filter': self.egress_filter,
 8008            'healthy': self.healthy,
 8009            'hostname': self.hostname,
 8010            'id': self.id,
 8011            'name': self.name,
 8012            'password': self.password,
 8013            'port': self.port,
 8014            'port_override': self.port_override,
 8015            'replica_set': self.replica_set,
 8016            'secret_store_id': self.secret_store_id,
 8017            'tags': self.tags,
 8018            'tls_required': self.tls_required,
 8019            'username': self.username,
 8020        }
 8021
 8022    @classmethod
 8023    def from_dict(cls, d):
 8024        return cls(
 8025            auth_database=d.get('auth_database'),
 8026            bind_interface=d.get('bind_interface'),
 8027            connect_to_replica=d.get('connect_to_replica'),
 8028            egress_filter=d.get('egress_filter'),
 8029            healthy=d.get('healthy'),
 8030            hostname=d.get('hostname'),
 8031            id=d.get('id'),
 8032            name=d.get('name'),
 8033            password=d.get('password'),
 8034            port=d.get('port'),
 8035            port_override=d.get('port_override'),
 8036            replica_set=d.get('replica_set'),
 8037            secret_store_id=d.get('secret_store_id'),
 8038            tags=d.get('tags'),
 8039            tls_required=d.get('tls_required'),
 8040            username=d.get('username'),
 8041        )
 8042
 8043
 8044class MongoShardedCluster:
 8045    '''
 8046    MongoShardedCluster is currently unstable, and its API may change, or it may be removed,
 8047    without a major version bump.
 8048    '''
 8049    __slots__ = [
 8050        'auth_database',
 8051        'bind_interface',
 8052        'egress_filter',
 8053        'healthy',
 8054        'hostname',
 8055        'id',
 8056        'name',
 8057        'password',
 8058        'port_override',
 8059        'secret_store_id',
 8060        'tags',
 8061        'tls_required',
 8062        'username',
 8063    ]
 8064
 8065    def __init__(
 8066        self,
 8067        auth_database=None,
 8068        bind_interface=None,
 8069        egress_filter=None,
 8070        healthy=None,
 8071        hostname=None,
 8072        id=None,
 8073        name=None,
 8074        password=None,
 8075        port_override=None,
 8076        secret_store_id=None,
 8077        tags=None,
 8078        tls_required=None,
 8079        username=None,
 8080    ):
 8081        self.auth_database = auth_database if auth_database is not None else ''
 8082        self.bind_interface = bind_interface if bind_interface is not None else ''
 8083        '''
 8084         Bind interface
 8085        '''
 8086        self.egress_filter = egress_filter if egress_filter is not None else ''
 8087        '''
 8088         A filter applied to the routing logic to pin datasource to nodes.
 8089        '''
 8090        self.healthy = healthy if healthy is not None else False
 8091        '''
 8092         True if the datasource is reachable and the credentials are valid.
 8093        '''
 8094        self.hostname = hostname if hostname is not None else ''
 8095        self.id = id if id is not None else ''
 8096        '''
 8097         Unique identifier of the Resource.
 8098        '''
 8099        self.name = name if name is not None else ''
 8100        '''
 8101         Unique human-readable name of the Resource.
 8102        '''
 8103        self.password = password if password is not None else ''
 8104        self.port_override = port_override if port_override is not None else 0
 8105        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8106        '''
 8107         ID of the secret store containing credentials for this resource, if any.
 8108        '''
 8109        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8110        '''
 8111         Tags is a map of key, value pairs.
 8112        '''
 8113        self.tls_required = tls_required if tls_required is not None else False
 8114        self.username = username if username is not None else ''
 8115
 8116    def __repr__(self):
 8117        return '<sdm.MongoShardedCluster ' + \
 8118            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8119            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8120            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8121            'healthy: ' + repr(self.healthy) + ' ' +\
 8122            'hostname: ' + repr(self.hostname) + ' ' +\
 8123            'id: ' + repr(self.id) + ' ' +\
 8124            'name: ' + repr(self.name) + ' ' +\
 8125            'password: ' + repr(self.password) + ' ' +\
 8126            'port_override: ' + repr(self.port_override) + ' ' +\
 8127            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8128            'tags: ' + repr(self.tags) + ' ' +\
 8129            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8130            'username: ' + repr(self.username) + ' ' +\
 8131            '>'
 8132
 8133    def to_dict(self):
 8134        return {
 8135            'auth_database': self.auth_database,
 8136            'bind_interface': self.bind_interface,
 8137            'egress_filter': self.egress_filter,
 8138            'healthy': self.healthy,
 8139            'hostname': self.hostname,
 8140            'id': self.id,
 8141            'name': self.name,
 8142            'password': self.password,
 8143            'port_override': self.port_override,
 8144            'secret_store_id': self.secret_store_id,
 8145            'tags': self.tags,
 8146            'tls_required': self.tls_required,
 8147            'username': self.username,
 8148        }
 8149
 8150    @classmethod
 8151    def from_dict(cls, d):
 8152        return cls(
 8153            auth_database=d.get('auth_database'),
 8154            bind_interface=d.get('bind_interface'),
 8155            egress_filter=d.get('egress_filter'),
 8156            healthy=d.get('healthy'),
 8157            hostname=d.get('hostname'),
 8158            id=d.get('id'),
 8159            name=d.get('name'),
 8160            password=d.get('password'),
 8161            port_override=d.get('port_override'),
 8162            secret_store_id=d.get('secret_store_id'),
 8163            tags=d.get('tags'),
 8164            tls_required=d.get('tls_required'),
 8165            username=d.get('username'),
 8166        )
 8167
 8168
 8169class Mysql:
 8170    __slots__ = [
 8171        'bind_interface',
 8172        'database',
 8173        'egress_filter',
 8174        'healthy',
 8175        'hostname',
 8176        'id',
 8177        'name',
 8178        'password',
 8179        'port',
 8180        'port_override',
 8181        'secret_store_id',
 8182        'tags',
 8183        'username',
 8184    ]
 8185
 8186    def __init__(
 8187        self,
 8188        bind_interface=None,
 8189        database=None,
 8190        egress_filter=None,
 8191        healthy=None,
 8192        hostname=None,
 8193        id=None,
 8194        name=None,
 8195        password=None,
 8196        port=None,
 8197        port_override=None,
 8198        secret_store_id=None,
 8199        tags=None,
 8200        username=None,
 8201    ):
 8202        self.bind_interface = bind_interface if bind_interface is not None else ''
 8203        '''
 8204         Bind interface
 8205        '''
 8206        self.database = database if database is not None else ''
 8207        self.egress_filter = egress_filter if egress_filter is not None else ''
 8208        '''
 8209         A filter applied to the routing logic to pin datasource to nodes.
 8210        '''
 8211        self.healthy = healthy if healthy is not None else False
 8212        '''
 8213         True if the datasource is reachable and the credentials are valid.
 8214        '''
 8215        self.hostname = hostname if hostname is not None else ''
 8216        self.id = id if id is not None else ''
 8217        '''
 8218         Unique identifier of the Resource.
 8219        '''
 8220        self.name = name if name is not None else ''
 8221        '''
 8222         Unique human-readable name of the Resource.
 8223        '''
 8224        self.password = password if password is not None else ''
 8225        self.port = port if port is not None else 0
 8226        self.port_override = port_override if port_override is not None else 0
 8227        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8228        '''
 8229         ID of the secret store containing credentials for this resource, if any.
 8230        '''
 8231        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8232        '''
 8233         Tags is a map of key, value pairs.
 8234        '''
 8235        self.username = username if username is not None else ''
 8236
 8237    def __repr__(self):
 8238        return '<sdm.Mysql ' + \
 8239            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8240            'database: ' + repr(self.database) + ' ' +\
 8241            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8242            'healthy: ' + repr(self.healthy) + ' ' +\
 8243            'hostname: ' + repr(self.hostname) + ' ' +\
 8244            'id: ' + repr(self.id) + ' ' +\
 8245            'name: ' + repr(self.name) + ' ' +\
 8246            'password: ' + repr(self.password) + ' ' +\
 8247            'port: ' + repr(self.port) + ' ' +\
 8248            'port_override: ' + repr(self.port_override) + ' ' +\
 8249            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8250            'tags: ' + repr(self.tags) + ' ' +\
 8251            'username: ' + repr(self.username) + ' ' +\
 8252            '>'
 8253
 8254    def to_dict(self):
 8255        return {
 8256            'bind_interface': self.bind_interface,
 8257            'database': self.database,
 8258            'egress_filter': self.egress_filter,
 8259            'healthy': self.healthy,
 8260            'hostname': self.hostname,
 8261            'id': self.id,
 8262            'name': self.name,
 8263            'password': self.password,
 8264            'port': self.port,
 8265            'port_override': self.port_override,
 8266            'secret_store_id': self.secret_store_id,
 8267            'tags': self.tags,
 8268            'username': self.username,
 8269        }
 8270
 8271    @classmethod
 8272    def from_dict(cls, d):
 8273        return cls(
 8274            bind_interface=d.get('bind_interface'),
 8275            database=d.get('database'),
 8276            egress_filter=d.get('egress_filter'),
 8277            healthy=d.get('healthy'),
 8278            hostname=d.get('hostname'),
 8279            id=d.get('id'),
 8280            name=d.get('name'),
 8281            password=d.get('password'),
 8282            port=d.get('port'),
 8283            port_override=d.get('port_override'),
 8284            secret_store_id=d.get('secret_store_id'),
 8285            tags=d.get('tags'),
 8286            username=d.get('username'),
 8287        )
 8288
 8289
 8290class Neptune:
 8291    __slots__ = [
 8292        'bind_interface',
 8293        'egress_filter',
 8294        'endpoint',
 8295        'healthy',
 8296        'id',
 8297        'name',
 8298        'port',
 8299        'port_override',
 8300        'secret_store_id',
 8301        'tags',
 8302    ]
 8303
 8304    def __init__(
 8305        self,
 8306        bind_interface=None,
 8307        egress_filter=None,
 8308        endpoint=None,
 8309        healthy=None,
 8310        id=None,
 8311        name=None,
 8312        port=None,
 8313        port_override=None,
 8314        secret_store_id=None,
 8315        tags=None,
 8316    ):
 8317        self.bind_interface = bind_interface if bind_interface is not None else ''
 8318        '''
 8319         Bind interface
 8320        '''
 8321        self.egress_filter = egress_filter if egress_filter is not None else ''
 8322        '''
 8323         A filter applied to the routing logic to pin datasource to nodes.
 8324        '''
 8325        self.endpoint = endpoint if endpoint is not None else ''
 8326        self.healthy = healthy if healthy is not None else False
 8327        '''
 8328         True if the datasource is reachable and the credentials are valid.
 8329        '''
 8330        self.id = id if id is not None else ''
 8331        '''
 8332         Unique identifier of the Resource.
 8333        '''
 8334        self.name = name if name is not None else ''
 8335        '''
 8336         Unique human-readable name of the Resource.
 8337        '''
 8338        self.port = port if port is not None else 0
 8339        self.port_override = port_override if port_override is not None else 0
 8340        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8341        '''
 8342         ID of the secret store containing credentials for this resource, if any.
 8343        '''
 8344        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8345        '''
 8346         Tags is a map of key, value pairs.
 8347        '''
 8348
 8349    def __repr__(self):
 8350        return '<sdm.Neptune ' + \
 8351            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8352            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8353            'endpoint: ' + repr(self.endpoint) + ' ' +\
 8354            'healthy: ' + repr(self.healthy) + ' ' +\
 8355            'id: ' + repr(self.id) + ' ' +\
 8356            'name: ' + repr(self.name) + ' ' +\
 8357            'port: ' + repr(self.port) + ' ' +\
 8358            'port_override: ' + repr(self.port_override) + ' ' +\
 8359            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8360            'tags: ' + repr(self.tags) + ' ' +\
 8361            '>'
 8362
 8363    def to_dict(self):
 8364        return {
 8365            'bind_interface': self.bind_interface,
 8366            'egress_filter': self.egress_filter,
 8367            'endpoint': self.endpoint,
 8368            'healthy': self.healthy,
 8369            'id': self.id,
 8370            'name': self.name,
 8371            'port': self.port,
 8372            'port_override': self.port_override,
 8373            'secret_store_id': self.secret_store_id,
 8374            'tags': self.tags,
 8375        }
 8376
 8377    @classmethod
 8378    def from_dict(cls, d):
 8379        return cls(
 8380            bind_interface=d.get('bind_interface'),
 8381            egress_filter=d.get('egress_filter'),
 8382            endpoint=d.get('endpoint'),
 8383            healthy=d.get('healthy'),
 8384            id=d.get('id'),
 8385            name=d.get('name'),
 8386            port=d.get('port'),
 8387            port_override=d.get('port_override'),
 8388            secret_store_id=d.get('secret_store_id'),
 8389            tags=d.get('tags'),
 8390        )
 8391
 8392
 8393class NeptuneIAM:
 8394    __slots__ = [
 8395        'access_key',
 8396        'bind_interface',
 8397        'egress_filter',
 8398        'endpoint',
 8399        'healthy',
 8400        'id',
 8401        'name',
 8402        'port',
 8403        'port_override',
 8404        'region',
 8405        'role_arn',
 8406        'role_external_id',
 8407        'secret_access_key',
 8408        'secret_store_id',
 8409        'tags',
 8410    ]
 8411
 8412    def __init__(
 8413        self,
 8414        access_key=None,
 8415        bind_interface=None,
 8416        egress_filter=None,
 8417        endpoint=None,
 8418        healthy=None,
 8419        id=None,
 8420        name=None,
 8421        port=None,
 8422        port_override=None,
 8423        region=None,
 8424        role_arn=None,
 8425        role_external_id=None,
 8426        secret_access_key=None,
 8427        secret_store_id=None,
 8428        tags=None,
 8429    ):
 8430        self.access_key = access_key if access_key is not None else ''
 8431        self.bind_interface = bind_interface if bind_interface is not None else ''
 8432        '''
 8433         Bind interface
 8434        '''
 8435        self.egress_filter = egress_filter if egress_filter is not None else ''
 8436        '''
 8437         A filter applied to the routing logic to pin datasource to nodes.
 8438        '''
 8439        self.endpoint = endpoint if endpoint is not None else ''
 8440        self.healthy = healthy if healthy is not None else False
 8441        '''
 8442         True if the datasource is reachable and the credentials are valid.
 8443        '''
 8444        self.id = id if id is not None else ''
 8445        '''
 8446         Unique identifier of the Resource.
 8447        '''
 8448        self.name = name if name is not None else ''
 8449        '''
 8450         Unique human-readable name of the Resource.
 8451        '''
 8452        self.port = port if port is not None else 0
 8453        self.port_override = port_override if port_override is not None else 0
 8454        self.region = region if region is not None else ''
 8455        self.role_arn = role_arn if role_arn is not None else ''
 8456        self.role_external_id = role_external_id if role_external_id is not None else ''
 8457        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 8458        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8459        '''
 8460         ID of the secret store containing credentials for this resource, if any.
 8461        '''
 8462        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8463        '''
 8464         Tags is a map of key, value pairs.
 8465        '''
 8466
 8467    def __repr__(self):
 8468        return '<sdm.NeptuneIAM ' + \
 8469            'access_key: ' + repr(self.access_key) + ' ' +\
 8470            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8471            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8472            'endpoint: ' + repr(self.endpoint) + ' ' +\
 8473            'healthy: ' + repr(self.healthy) + ' ' +\
 8474            'id: ' + repr(self.id) + ' ' +\
 8475            'name: ' + repr(self.name) + ' ' +\
 8476            'port: ' + repr(self.port) + ' ' +\
 8477            'port_override: ' + repr(self.port_override) + ' ' +\
 8478            'region: ' + repr(self.region) + ' ' +\
 8479            'role_arn: ' + repr(self.role_arn) + ' ' +\
 8480            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 8481            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 8482            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8483            'tags: ' + repr(self.tags) + ' ' +\
 8484            '>'
 8485
 8486    def to_dict(self):
 8487        return {
 8488            'access_key': self.access_key,
 8489            'bind_interface': self.bind_interface,
 8490            'egress_filter': self.egress_filter,
 8491            'endpoint': self.endpoint,
 8492            'healthy': self.healthy,
 8493            'id': self.id,
 8494            'name': self.name,
 8495            'port': self.port,
 8496            'port_override': self.port_override,
 8497            'region': self.region,
 8498            'role_arn': self.role_arn,
 8499            'role_external_id': self.role_external_id,
 8500            'secret_access_key': self.secret_access_key,
 8501            'secret_store_id': self.secret_store_id,
 8502            'tags': self.tags,
 8503        }
 8504
 8505    @classmethod
 8506    def from_dict(cls, d):
 8507        return cls(
 8508            access_key=d.get('access_key'),
 8509            bind_interface=d.get('bind_interface'),
 8510            egress_filter=d.get('egress_filter'),
 8511            endpoint=d.get('endpoint'),
 8512            healthy=d.get('healthy'),
 8513            id=d.get('id'),
 8514            name=d.get('name'),
 8515            port=d.get('port'),
 8516            port_override=d.get('port_override'),
 8517            region=d.get('region'),
 8518            role_arn=d.get('role_arn'),
 8519            role_external_id=d.get('role_external_id'),
 8520            secret_access_key=d.get('secret_access_key'),
 8521            secret_store_id=d.get('secret_store_id'),
 8522            tags=d.get('tags'),
 8523        )
 8524
 8525
 8526class NodeCreateResponse:
 8527    '''
 8528         NodeCreateResponse reports how the Nodes were created in the system.
 8529    '''
 8530    __slots__ = [
 8531        'meta',
 8532        'node',
 8533        'rate_limit',
 8534        'token',
 8535    ]
 8536
 8537    def __init__(
 8538        self,
 8539        meta=None,
 8540        node=None,
 8541        rate_limit=None,
 8542        token=None,
 8543    ):
 8544        self.meta = meta if meta is not None else None
 8545        '''
 8546         Reserved for future use.
 8547        '''
 8548        self.node = node if node is not None else None
 8549        '''
 8550         The created Node.
 8551        '''
 8552        self.rate_limit = rate_limit if rate_limit is not None else None
 8553        '''
 8554         Rate limit information.
 8555        '''
 8556        self.token = token if token is not None else ''
 8557        '''
 8558         The auth token generated for the Node. The Node will use this token to
 8559         authenticate with the strongDM API.
 8560        '''
 8561
 8562    def __repr__(self):
 8563        return '<sdm.NodeCreateResponse ' + \
 8564            'meta: ' + repr(self.meta) + ' ' +\
 8565            'node: ' + repr(self.node) + ' ' +\
 8566            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8567            'token: ' + repr(self.token) + ' ' +\
 8568            '>'
 8569
 8570    def to_dict(self):
 8571        return {
 8572            'meta': self.meta,
 8573            'node': self.node,
 8574            'rate_limit': self.rate_limit,
 8575            'token': self.token,
 8576        }
 8577
 8578    @classmethod
 8579    def from_dict(cls, d):
 8580        return cls(
 8581            meta=d.get('meta'),
 8582            node=d.get('node'),
 8583            rate_limit=d.get('rate_limit'),
 8584            token=d.get('token'),
 8585        )
 8586
 8587
 8588class NodeDeleteResponse:
 8589    '''
 8590         NodeDeleteResponse returns information about a Node that was deleted.
 8591    '''
 8592    __slots__ = [
 8593        'meta',
 8594        'rate_limit',
 8595    ]
 8596
 8597    def __init__(
 8598        self,
 8599        meta=None,
 8600        rate_limit=None,
 8601    ):
 8602        self.meta = meta if meta is not None else None
 8603        '''
 8604         Reserved for future use.
 8605        '''
 8606        self.rate_limit = rate_limit if rate_limit is not None else None
 8607        '''
 8608         Rate limit information.
 8609        '''
 8610
 8611    def __repr__(self):
 8612        return '<sdm.NodeDeleteResponse ' + \
 8613            'meta: ' + repr(self.meta) + ' ' +\
 8614            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8615            '>'
 8616
 8617    def to_dict(self):
 8618        return {
 8619            'meta': self.meta,
 8620            'rate_limit': self.rate_limit,
 8621        }
 8622
 8623    @classmethod
 8624    def from_dict(cls, d):
 8625        return cls(
 8626            meta=d.get('meta'),
 8627            rate_limit=d.get('rate_limit'),
 8628        )
 8629
 8630
 8631class NodeGetResponse:
 8632    '''
 8633         NodeGetResponse returns a requested Node.
 8634    '''
 8635    __slots__ = [
 8636        'meta',
 8637        'node',
 8638        'rate_limit',
 8639    ]
 8640
 8641    def __init__(
 8642        self,
 8643        meta=None,
 8644        node=None,
 8645        rate_limit=None,
 8646    ):
 8647        self.meta = meta if meta is not None else None
 8648        '''
 8649         Reserved for future use.
 8650        '''
 8651        self.node = node if node is not None else None
 8652        '''
 8653         The requested Node.
 8654        '''
 8655        self.rate_limit = rate_limit if rate_limit is not None else None
 8656        '''
 8657         Rate limit information.
 8658        '''
 8659
 8660    def __repr__(self):
 8661        return '<sdm.NodeGetResponse ' + \
 8662            'meta: ' + repr(self.meta) + ' ' +\
 8663            'node: ' + repr(self.node) + ' ' +\
 8664            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8665            '>'
 8666
 8667    def to_dict(self):
 8668        return {
 8669            'meta': self.meta,
 8670            'node': self.node,
 8671            'rate_limit': self.rate_limit,
 8672        }
 8673
 8674    @classmethod
 8675    def from_dict(cls, d):
 8676        return cls(
 8677            meta=d.get('meta'),
 8678            node=d.get('node'),
 8679            rate_limit=d.get('rate_limit'),
 8680        )
 8681
 8682
 8683class NodeUpdateResponse:
 8684    '''
 8685         NodeUpdateResponse returns the fields of a Node after it has been updated by
 8686     a NodeUpdateRequest.
 8687    '''
 8688    __slots__ = [
 8689        'meta',
 8690        'node',
 8691        'rate_limit',
 8692    ]
 8693
 8694    def __init__(
 8695        self,
 8696        meta=None,
 8697        node=None,
 8698        rate_limit=None,
 8699    ):
 8700        self.meta = meta if meta is not None else None
 8701        '''
 8702         Reserved for future use.
 8703        '''
 8704        self.node = node if node is not None else None
 8705        '''
 8706         The updated Node.
 8707        '''
 8708        self.rate_limit = rate_limit if rate_limit is not None else None
 8709        '''
 8710         Rate limit information.
 8711        '''
 8712
 8713    def __repr__(self):
 8714        return '<sdm.NodeUpdateResponse ' + \
 8715            'meta: ' + repr(self.meta) + ' ' +\
 8716            'node: ' + repr(self.node) + ' ' +\
 8717            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8718            '>'
 8719
 8720    def to_dict(self):
 8721        return {
 8722            'meta': self.meta,
 8723            'node': self.node,
 8724            'rate_limit': self.rate_limit,
 8725        }
 8726
 8727    @classmethod
 8728    def from_dict(cls, d):
 8729        return cls(
 8730            meta=d.get('meta'),
 8731            node=d.get('node'),
 8732            rate_limit=d.get('rate_limit'),
 8733        )
 8734
 8735
 8736class Oracle:
 8737    __slots__ = [
 8738        'bind_interface',
 8739        'database',
 8740        'egress_filter',
 8741        'healthy',
 8742        'hostname',
 8743        'id',
 8744        'name',
 8745        'password',
 8746        'port',
 8747        'port_override',
 8748        'secret_store_id',
 8749        'tags',
 8750        'tls_required',
 8751        'username',
 8752    ]
 8753
 8754    def __init__(
 8755        self,
 8756        bind_interface=None,
 8757        database=None,
 8758        egress_filter=None,
 8759        healthy=None,
 8760        hostname=None,
 8761        id=None,
 8762        name=None,
 8763        password=None,
 8764        port=None,
 8765        port_override=None,
 8766        secret_store_id=None,
 8767        tags=None,
 8768        tls_required=None,
 8769        username=None,
 8770    ):
 8771        self.bind_interface = bind_interface if bind_interface is not None else ''
 8772        '''
 8773         Bind interface
 8774        '''
 8775        self.database = database if database is not None else ''
 8776        self.egress_filter = egress_filter if egress_filter is not None else ''
 8777        '''
 8778         A filter applied to the routing logic to pin datasource to nodes.
 8779        '''
 8780        self.healthy = healthy if healthy is not None else False
 8781        '''
 8782         True if the datasource is reachable and the credentials are valid.
 8783        '''
 8784        self.hostname = hostname if hostname is not None else ''
 8785        self.id = id if id is not None else ''
 8786        '''
 8787         Unique identifier of the Resource.
 8788        '''
 8789        self.name = name if name is not None else ''
 8790        '''
 8791         Unique human-readable name of the Resource.
 8792        '''
 8793        self.password = password if password is not None else ''
 8794        self.port = port if port is not None else 0
 8795        self.port_override = port_override if port_override is not None else 0
 8796        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8797        '''
 8798         ID of the secret store containing credentials for this resource, if any.
 8799        '''
 8800        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8801        '''
 8802         Tags is a map of key, value pairs.
 8803        '''
 8804        self.tls_required = tls_required if tls_required is not None else False
 8805        self.username = username if username is not None else ''
 8806
 8807    def __repr__(self):
 8808        return '<sdm.Oracle ' + \
 8809            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8810            'database: ' + repr(self.database) + ' ' +\
 8811            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8812            'healthy: ' + repr(self.healthy) + ' ' +\
 8813            'hostname: ' + repr(self.hostname) + ' ' +\
 8814            'id: ' + repr(self.id) + ' ' +\
 8815            'name: ' + repr(self.name) + ' ' +\
 8816            'password: ' + repr(self.password) + ' ' +\
 8817            'port: ' + repr(self.port) + ' ' +\
 8818            'port_override: ' + repr(self.port_override) + ' ' +\
 8819            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8820            'tags: ' + repr(self.tags) + ' ' +\
 8821            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8822            'username: ' + repr(self.username) + ' ' +\
 8823            '>'
 8824
 8825    def to_dict(self):
 8826        return {
 8827            'bind_interface': self.bind_interface,
 8828            'database': self.database,
 8829            'egress_filter': self.egress_filter,
 8830            'healthy': self.healthy,
 8831            'hostname': self.hostname,
 8832            'id': self.id,
 8833            'name': self.name,
 8834            'password': self.password,
 8835            'port': self.port,
 8836            'port_override': self.port_override,
 8837            'secret_store_id': self.secret_store_id,
 8838            'tags': self.tags,
 8839            'tls_required': self.tls_required,
 8840            'username': self.username,
 8841        }
 8842
 8843    @classmethod
 8844    def from_dict(cls, d):
 8845        return cls(
 8846            bind_interface=d.get('bind_interface'),
 8847            database=d.get('database'),
 8848            egress_filter=d.get('egress_filter'),
 8849            healthy=d.get('healthy'),
 8850            hostname=d.get('hostname'),
 8851            id=d.get('id'),
 8852            name=d.get('name'),
 8853            password=d.get('password'),
 8854            port=d.get('port'),
 8855            port_override=d.get('port_override'),
 8856            secret_store_id=d.get('secret_store_id'),
 8857            tags=d.get('tags'),
 8858            tls_required=d.get('tls_required'),
 8859            username=d.get('username'),
 8860        )
 8861
 8862
 8863class Postgres:
 8864    __slots__ = [
 8865        'bind_interface',
 8866        'database',
 8867        'egress_filter',
 8868        'healthy',
 8869        'hostname',
 8870        'id',
 8871        'name',
 8872        'override_database',
 8873        'password',
 8874        'port',
 8875        'port_override',
 8876        'secret_store_id',
 8877        'tags',
 8878        'username',
 8879    ]
 8880
 8881    def __init__(
 8882        self,
 8883        bind_interface=None,
 8884        database=None,
 8885        egress_filter=None,
 8886        healthy=None,
 8887        hostname=None,
 8888        id=None,
 8889        name=None,
 8890        override_database=None,
 8891        password=None,
 8892        port=None,
 8893        port_override=None,
 8894        secret_store_id=None,
 8895        tags=None,
 8896        username=None,
 8897    ):
 8898        self.bind_interface = bind_interface if bind_interface is not None else ''
 8899        '''
 8900         Bind interface
 8901        '''
 8902        self.database = database if database is not None else ''
 8903        self.egress_filter = egress_filter if egress_filter is not None else ''
 8904        '''
 8905         A filter applied to the routing logic to pin datasource to nodes.
 8906        '''
 8907        self.healthy = healthy if healthy is not None else False
 8908        '''
 8909         True if the datasource is reachable and the credentials are valid.
 8910        '''
 8911        self.hostname = hostname if hostname is not None else ''
 8912        self.id = id if id is not None else ''
 8913        '''
 8914         Unique identifier of the Resource.
 8915        '''
 8916        self.name = name if name is not None else ''
 8917        '''
 8918         Unique human-readable name of the Resource.
 8919        '''
 8920        self.override_database = override_database if override_database is not None else False
 8921        self.password = password if password is not None else ''
 8922        self.port = port if port is not None else 0
 8923        self.port_override = port_override if port_override is not None else 0
 8924        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8925        '''
 8926         ID of the secret store containing credentials for this resource, if any.
 8927        '''
 8928        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8929        '''
 8930         Tags is a map of key, value pairs.
 8931        '''
 8932        self.username = username if username is not None else ''
 8933
 8934    def __repr__(self):
 8935        return '<sdm.Postgres ' + \
 8936            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8937            'database: ' + repr(self.database) + ' ' +\
 8938            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8939            'healthy: ' + repr(self.healthy) + ' ' +\
 8940            'hostname: ' + repr(self.hostname) + ' ' +\
 8941            'id: ' + repr(self.id) + ' ' +\
 8942            'name: ' + repr(self.name) + ' ' +\
 8943            'override_database: ' + repr(self.override_database) + ' ' +\
 8944            'password: ' + repr(self.password) + ' ' +\
 8945            'port: ' + repr(self.port) + ' ' +\
 8946            'port_override: ' + repr(self.port_override) + ' ' +\
 8947            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8948            'tags: ' + repr(self.tags) + ' ' +\
 8949            'username: ' + repr(self.username) + ' ' +\
 8950            '>'
 8951
 8952    def to_dict(self):
 8953        return {
 8954            'bind_interface': self.bind_interface,
 8955            'database': self.database,
 8956            'egress_filter': self.egress_filter,
 8957            'healthy': self.healthy,
 8958            'hostname': self.hostname,
 8959            'id': self.id,
 8960            'name': self.name,
 8961            'override_database': self.override_database,
 8962            'password': self.password,
 8963            'port': self.port,
 8964            'port_override': self.port_override,
 8965            'secret_store_id': self.secret_store_id,
 8966            'tags': self.tags,
 8967            'username': self.username,
 8968        }
 8969
 8970    @classmethod
 8971    def from_dict(cls, d):
 8972        return cls(
 8973            bind_interface=d.get('bind_interface'),
 8974            database=d.get('database'),
 8975            egress_filter=d.get('egress_filter'),
 8976            healthy=d.get('healthy'),
 8977            hostname=d.get('hostname'),
 8978            id=d.get('id'),
 8979            name=d.get('name'),
 8980            override_database=d.get('override_database'),
 8981            password=d.get('password'),
 8982            port=d.get('port'),
 8983            port_override=d.get('port_override'),
 8984            secret_store_id=d.get('secret_store_id'),
 8985            tags=d.get('tags'),
 8986            username=d.get('username'),
 8987        )
 8988
 8989
 8990class Presto:
 8991    __slots__ = [
 8992        'bind_interface',
 8993        'database',
 8994        'egress_filter',
 8995        'healthy',
 8996        'hostname',
 8997        'id',
 8998        'name',
 8999        'password',
 9000        'port',
 9001        'port_override',
 9002        'secret_store_id',
 9003        'tags',
 9004        'tls_required',
 9005        'username',
 9006    ]
 9007
 9008    def __init__(
 9009        self,
 9010        bind_interface=None,
 9011        database=None,
 9012        egress_filter=None,
 9013        healthy=None,
 9014        hostname=None,
 9015        id=None,
 9016        name=None,
 9017        password=None,
 9018        port=None,
 9019        port_override=None,
 9020        secret_store_id=None,
 9021        tags=None,
 9022        tls_required=None,
 9023        username=None,
 9024    ):
 9025        self.bind_interface = bind_interface if bind_interface is not None else ''
 9026        '''
 9027         Bind interface
 9028        '''
 9029        self.database = database if database is not None else ''
 9030        self.egress_filter = egress_filter if egress_filter is not None else ''
 9031        '''
 9032         A filter applied to the routing logic to pin datasource to nodes.
 9033        '''
 9034        self.healthy = healthy if healthy is not None else False
 9035        '''
 9036         True if the datasource is reachable and the credentials are valid.
 9037        '''
 9038        self.hostname = hostname if hostname is not None else ''
 9039        self.id = id if id is not None else ''
 9040        '''
 9041         Unique identifier of the Resource.
 9042        '''
 9043        self.name = name if name is not None else ''
 9044        '''
 9045         Unique human-readable name of the Resource.
 9046        '''
 9047        self.password = password if password is not None else ''
 9048        self.port = port if port is not None else 0
 9049        self.port_override = port_override if port_override is not None else 0
 9050        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9051        '''
 9052         ID of the secret store containing credentials for this resource, if any.
 9053        '''
 9054        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9055        '''
 9056         Tags is a map of key, value pairs.
 9057        '''
 9058        self.tls_required = tls_required if tls_required is not None else False
 9059        self.username = username if username is not None else ''
 9060
 9061    def __repr__(self):
 9062        return '<sdm.Presto ' + \
 9063            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9064            'database: ' + repr(self.database) + ' ' +\
 9065            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9066            'healthy: ' + repr(self.healthy) + ' ' +\
 9067            'hostname: ' + repr(self.hostname) + ' ' +\
 9068            'id: ' + repr(self.id) + ' ' +\
 9069            'name: ' + repr(self.name) + ' ' +\
 9070            'password: ' + repr(self.password) + ' ' +\
 9071            'port: ' + repr(self.port) + ' ' +\
 9072            'port_override: ' + repr(self.port_override) + ' ' +\
 9073            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9074            'tags: ' + repr(self.tags) + ' ' +\
 9075            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9076            'username: ' + repr(self.username) + ' ' +\
 9077            '>'
 9078
 9079    def to_dict(self):
 9080        return {
 9081            'bind_interface': self.bind_interface,
 9082            'database': self.database,
 9083            'egress_filter': self.egress_filter,
 9084            'healthy': self.healthy,
 9085            'hostname': self.hostname,
 9086            'id': self.id,
 9087            'name': self.name,
 9088            'password': self.password,
 9089            'port': self.port,
 9090            'port_override': self.port_override,
 9091            'secret_store_id': self.secret_store_id,
 9092            'tags': self.tags,
 9093            'tls_required': self.tls_required,
 9094            'username': self.username,
 9095        }
 9096
 9097    @classmethod
 9098    def from_dict(cls, d):
 9099        return cls(
 9100            bind_interface=d.get('bind_interface'),
 9101            database=d.get('database'),
 9102            egress_filter=d.get('egress_filter'),
 9103            healthy=d.get('healthy'),
 9104            hostname=d.get('hostname'),
 9105            id=d.get('id'),
 9106            name=d.get('name'),
 9107            password=d.get('password'),
 9108            port=d.get('port'),
 9109            port_override=d.get('port_override'),
 9110            secret_store_id=d.get('secret_store_id'),
 9111            tags=d.get('tags'),
 9112            tls_required=d.get('tls_required'),
 9113            username=d.get('username'),
 9114        )
 9115
 9116
 9117class RDP:
 9118    __slots__ = [
 9119        'bind_interface',
 9120        'downgrade_nla_connections',
 9121        'egress_filter',
 9122        'healthy',
 9123        'hostname',
 9124        'id',
 9125        'name',
 9126        'password',
 9127        'port',
 9128        'port_override',
 9129        'secret_store_id',
 9130        'tags',
 9131        'username',
 9132    ]
 9133
 9134    def __init__(
 9135        self,
 9136        bind_interface=None,
 9137        downgrade_nla_connections=None,
 9138        egress_filter=None,
 9139        healthy=None,
 9140        hostname=None,
 9141        id=None,
 9142        name=None,
 9143        password=None,
 9144        port=None,
 9145        port_override=None,
 9146        secret_store_id=None,
 9147        tags=None,
 9148        username=None,
 9149    ):
 9150        self.bind_interface = bind_interface if bind_interface is not None else ''
 9151        '''
 9152         Bind interface
 9153        '''
 9154        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
 9155        self.egress_filter = egress_filter if egress_filter is not None else ''
 9156        '''
 9157         A filter applied to the routing logic to pin datasource to nodes.
 9158        '''
 9159        self.healthy = healthy if healthy is not None else False
 9160        '''
 9161         True if the datasource is reachable and the credentials are valid.
 9162        '''
 9163        self.hostname = hostname if hostname is not None else ''
 9164        self.id = id if id is not None else ''
 9165        '''
 9166         Unique identifier of the Resource.
 9167        '''
 9168        self.name = name if name is not None else ''
 9169        '''
 9170         Unique human-readable name of the Resource.
 9171        '''
 9172        self.password = password if password is not None else ''
 9173        self.port = port if port is not None else 0
 9174        self.port_override = port_override if port_override is not None else 0
 9175        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9176        '''
 9177         ID of the secret store containing credentials for this resource, if any.
 9178        '''
 9179        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9180        '''
 9181         Tags is a map of key, value pairs.
 9182        '''
 9183        self.username = username if username is not None else ''
 9184
 9185    def __repr__(self):
 9186        return '<sdm.RDP ' + \
 9187            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9188            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
 9189            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9190            'healthy: ' + repr(self.healthy) + ' ' +\
 9191            'hostname: ' + repr(self.hostname) + ' ' +\
 9192            'id: ' + repr(self.id) + ' ' +\
 9193            'name: ' + repr(self.name) + ' ' +\
 9194            'password: ' + repr(self.password) + ' ' +\
 9195            'port: ' + repr(self.port) + ' ' +\
 9196            'port_override: ' + repr(self.port_override) + ' ' +\
 9197            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9198            'tags: ' + repr(self.tags) + ' ' +\
 9199            'username: ' + repr(self.username) + ' ' +\
 9200            '>'
 9201
 9202    def to_dict(self):
 9203        return {
 9204            'bind_interface': self.bind_interface,
 9205            'downgrade_nla_connections': self.downgrade_nla_connections,
 9206            'egress_filter': self.egress_filter,
 9207            'healthy': self.healthy,
 9208            'hostname': self.hostname,
 9209            'id': self.id,
 9210            'name': self.name,
 9211            'password': self.password,
 9212            'port': self.port,
 9213            'port_override': self.port_override,
 9214            'secret_store_id': self.secret_store_id,
 9215            'tags': self.tags,
 9216            'username': self.username,
 9217        }
 9218
 9219    @classmethod
 9220    def from_dict(cls, d):
 9221        return cls(
 9222            bind_interface=d.get('bind_interface'),
 9223            downgrade_nla_connections=d.get('downgrade_nla_connections'),
 9224            egress_filter=d.get('egress_filter'),
 9225            healthy=d.get('healthy'),
 9226            hostname=d.get('hostname'),
 9227            id=d.get('id'),
 9228            name=d.get('name'),
 9229            password=d.get('password'),
 9230            port=d.get('port'),
 9231            port_override=d.get('port_override'),
 9232            secret_store_id=d.get('secret_store_id'),
 9233            tags=d.get('tags'),
 9234            username=d.get('username'),
 9235        )
 9236
 9237
 9238class RabbitMQAMQP091:
 9239    __slots__ = [
 9240        'bind_interface',
 9241        'egress_filter',
 9242        'healthy',
 9243        'hostname',
 9244        'id',
 9245        'name',
 9246        'password',
 9247        'port',
 9248        'port_override',
 9249        'secret_store_id',
 9250        'tags',
 9251        'tls_required',
 9252        'username',
 9253    ]
 9254
 9255    def __init__(
 9256        self,
 9257        bind_interface=None,
 9258        egress_filter=None,
 9259        healthy=None,
 9260        hostname=None,
 9261        id=None,
 9262        name=None,
 9263        password=None,
 9264        port=None,
 9265        port_override=None,
 9266        secret_store_id=None,
 9267        tags=None,
 9268        tls_required=None,
 9269        username=None,
 9270    ):
 9271        self.bind_interface = bind_interface if bind_interface is not None else ''
 9272        '''
 9273         Bind interface
 9274        '''
 9275        self.egress_filter = egress_filter if egress_filter is not None else ''
 9276        '''
 9277         A filter applied to the routing logic to pin datasource to nodes.
 9278        '''
 9279        self.healthy = healthy if healthy is not None else False
 9280        '''
 9281         True if the datasource is reachable and the credentials are valid.
 9282        '''
 9283        self.hostname = hostname if hostname is not None else ''
 9284        self.id = id if id is not None else ''
 9285        '''
 9286         Unique identifier of the Resource.
 9287        '''
 9288        self.name = name if name is not None else ''
 9289        '''
 9290         Unique human-readable name of the Resource.
 9291        '''
 9292        self.password = password if password is not None else ''
 9293        self.port = port if port is not None else 0
 9294        self.port_override = port_override if port_override is not None else 0
 9295        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9296        '''
 9297         ID of the secret store containing credentials for this resource, if any.
 9298        '''
 9299        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9300        '''
 9301         Tags is a map of key, value pairs.
 9302        '''
 9303        self.tls_required = tls_required if tls_required is not None else False
 9304        self.username = username if username is not None else ''
 9305
 9306    def __repr__(self):
 9307        return '<sdm.RabbitMQAMQP091 ' + \
 9308            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9309            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9310            'healthy: ' + repr(self.healthy) + ' ' +\
 9311            'hostname: ' + repr(self.hostname) + ' ' +\
 9312            'id: ' + repr(self.id) + ' ' +\
 9313            'name: ' + repr(self.name) + ' ' +\
 9314            'password: ' + repr(self.password) + ' ' +\
 9315            'port: ' + repr(self.port) + ' ' +\
 9316            'port_override: ' + repr(self.port_override) + ' ' +\
 9317            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9318            'tags: ' + repr(self.tags) + ' ' +\
 9319            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9320            'username: ' + repr(self.username) + ' ' +\
 9321            '>'
 9322
 9323    def to_dict(self):
 9324        return {
 9325            'bind_interface': self.bind_interface,
 9326            'egress_filter': self.egress_filter,
 9327            'healthy': self.healthy,
 9328            'hostname': self.hostname,
 9329            'id': self.id,
 9330            'name': self.name,
 9331            'password': self.password,
 9332            'port': self.port,
 9333            'port_override': self.port_override,
 9334            'secret_store_id': self.secret_store_id,
 9335            'tags': self.tags,
 9336            'tls_required': self.tls_required,
 9337            'username': self.username,
 9338        }
 9339
 9340    @classmethod
 9341    def from_dict(cls, d):
 9342        return cls(
 9343            bind_interface=d.get('bind_interface'),
 9344            egress_filter=d.get('egress_filter'),
 9345            healthy=d.get('healthy'),
 9346            hostname=d.get('hostname'),
 9347            id=d.get('id'),
 9348            name=d.get('name'),
 9349            password=d.get('password'),
 9350            port=d.get('port'),
 9351            port_override=d.get('port_override'),
 9352            secret_store_id=d.get('secret_store_id'),
 9353            tags=d.get('tags'),
 9354            tls_required=d.get('tls_required'),
 9355            username=d.get('username'),
 9356        )
 9357
 9358
 9359class RateLimitMetadata:
 9360    '''
 9361         RateLimitMetadata contains information about remaining requests avaialable
 9362     to the user over some timeframe.
 9363    '''
 9364    __slots__ = [
 9365        'bucket',
 9366        'limit',
 9367        'remaining',
 9368        'reset_at',
 9369    ]
 9370
 9371    def __init__(
 9372        self,
 9373        bucket=None,
 9374        limit=None,
 9375        remaining=None,
 9376        reset_at=None,
 9377    ):
 9378        self.bucket = bucket if bucket is not None else ''
 9379        '''
 9380         The bucket this user/token is associated with, which may be shared between
 9381         multiple users/tokens.
 9382        '''
 9383        self.limit = limit if limit is not None else 0
 9384        '''
 9385         How many total requests the user/token is authorized to make before being
 9386         rate limited.
 9387        '''
 9388        self.remaining = remaining if remaining is not None else 0
 9389        '''
 9390         How many remaining requests out of the limit are still avaialable.
 9391        '''
 9392        self.reset_at = reset_at if reset_at is not None else None
 9393        '''
 9394         The time when remaining will be reset to limit.
 9395        '''
 9396
 9397    def __repr__(self):
 9398        return '<sdm.RateLimitMetadata ' + \
 9399            'bucket: ' + repr(self.bucket) + ' ' +\
 9400            'limit: ' + repr(self.limit) + ' ' +\
 9401            'remaining: ' + repr(self.remaining) + ' ' +\
 9402            'reset_at: ' + repr(self.reset_at) + ' ' +\
 9403            '>'
 9404
 9405    def to_dict(self):
 9406        return {
 9407            'bucket': self.bucket,
 9408            'limit': self.limit,
 9409            'remaining': self.remaining,
 9410            'reset_at': self.reset_at,
 9411        }
 9412
 9413    @classmethod
 9414    def from_dict(cls, d):
 9415        return cls(
 9416            bucket=d.get('bucket'),
 9417            limit=d.get('limit'),
 9418            remaining=d.get('remaining'),
 9419            reset_at=d.get('reset_at'),
 9420        )
 9421
 9422
 9423class RawTCP:
 9424    __slots__ = [
 9425        'bind_interface',
 9426        'egress_filter',
 9427        'healthy',
 9428        'hostname',
 9429        'id',
 9430        'name',
 9431        'port',
 9432        'port_override',
 9433        'secret_store_id',
 9434        'tags',
 9435    ]
 9436
 9437    def __init__(
 9438        self,
 9439        bind_interface=None,
 9440        egress_filter=None,
 9441        healthy=None,
 9442        hostname=None,
 9443        id=None,
 9444        name=None,
 9445        port=None,
 9446        port_override=None,
 9447        secret_store_id=None,
 9448        tags=None,
 9449    ):
 9450        self.bind_interface = bind_interface if bind_interface is not None else ''
 9451        '''
 9452         Bind interface
 9453        '''
 9454        self.egress_filter = egress_filter if egress_filter is not None else ''
 9455        '''
 9456         A filter applied to the routing logic to pin datasource to nodes.
 9457        '''
 9458        self.healthy = healthy if healthy is not None else False
 9459        '''
 9460         True if the datasource is reachable and the credentials are valid.
 9461        '''
 9462        self.hostname = hostname if hostname is not None else ''
 9463        self.id = id if id is not None else ''
 9464        '''
 9465         Unique identifier of the Resource.
 9466        '''
 9467        self.name = name if name is not None else ''
 9468        '''
 9469         Unique human-readable name of the Resource.
 9470        '''
 9471        self.port = port if port is not None else 0
 9472        self.port_override = port_override if port_override is not None else 0
 9473        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9474        '''
 9475         ID of the secret store containing credentials for this resource, if any.
 9476        '''
 9477        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9478        '''
 9479         Tags is a map of key, value pairs.
 9480        '''
 9481
 9482    def __repr__(self):
 9483        return '<sdm.RawTCP ' + \
 9484            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9485            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9486            'healthy: ' + repr(self.healthy) + ' ' +\
 9487            'hostname: ' + repr(self.hostname) + ' ' +\
 9488            'id: ' + repr(self.id) + ' ' +\
 9489            'name: ' + repr(self.name) + ' ' +\
 9490            'port: ' + repr(self.port) + ' ' +\
 9491            'port_override: ' + repr(self.port_override) + ' ' +\
 9492            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9493            'tags: ' + repr(self.tags) + ' ' +\
 9494            '>'
 9495
 9496    def to_dict(self):
 9497        return {
 9498            'bind_interface': self.bind_interface,
 9499            'egress_filter': self.egress_filter,
 9500            'healthy': self.healthy,
 9501            'hostname': self.hostname,
 9502            'id': self.id,
 9503            'name': self.name,
 9504            'port': self.port,
 9505            'port_override': self.port_override,
 9506            'secret_store_id': self.secret_store_id,
 9507            'tags': self.tags,
 9508        }
 9509
 9510    @classmethod
 9511    def from_dict(cls, d):
 9512        return cls(
 9513            bind_interface=d.get('bind_interface'),
 9514            egress_filter=d.get('egress_filter'),
 9515            healthy=d.get('healthy'),
 9516            hostname=d.get('hostname'),
 9517            id=d.get('id'),
 9518            name=d.get('name'),
 9519            port=d.get('port'),
 9520            port_override=d.get('port_override'),
 9521            secret_store_id=d.get('secret_store_id'),
 9522            tags=d.get('tags'),
 9523        )
 9524
 9525
 9526class Redis:
 9527    __slots__ = [
 9528        'bind_interface',
 9529        'egress_filter',
 9530        'healthy',
 9531        'hostname',
 9532        'id',
 9533        'name',
 9534        'password',
 9535        'port',
 9536        'port_override',
 9537        'secret_store_id',
 9538        'tags',
 9539        'tls_required',
 9540        'username',
 9541    ]
 9542
 9543    def __init__(
 9544        self,
 9545        bind_interface=None,
 9546        egress_filter=None,
 9547        healthy=None,
 9548        hostname=None,
 9549        id=None,
 9550        name=None,
 9551        password=None,
 9552        port=None,
 9553        port_override=None,
 9554        secret_store_id=None,
 9555        tags=None,
 9556        tls_required=None,
 9557        username=None,
 9558    ):
 9559        self.bind_interface = bind_interface if bind_interface is not None else ''
 9560        '''
 9561         Bind interface
 9562        '''
 9563        self.egress_filter = egress_filter if egress_filter is not None else ''
 9564        '''
 9565         A filter applied to the routing logic to pin datasource to nodes.
 9566        '''
 9567        self.healthy = healthy if healthy is not None else False
 9568        '''
 9569         True if the datasource is reachable and the credentials are valid.
 9570        '''
 9571        self.hostname = hostname if hostname is not None else ''
 9572        self.id = id if id is not None else ''
 9573        '''
 9574         Unique identifier of the Resource.
 9575        '''
 9576        self.name = name if name is not None else ''
 9577        '''
 9578         Unique human-readable name of the Resource.
 9579        '''
 9580        self.password = password if password is not None else ''
 9581        self.port = port if port is not None else 0
 9582        self.port_override = port_override if port_override is not None else 0
 9583        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9584        '''
 9585         ID of the secret store containing credentials for this resource, if any.
 9586        '''
 9587        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9588        '''
 9589         Tags is a map of key, value pairs.
 9590        '''
 9591        self.tls_required = tls_required if tls_required is not None else False
 9592        self.username = username if username is not None else ''
 9593
 9594    def __repr__(self):
 9595        return '<sdm.Redis ' + \
 9596            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9597            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9598            'healthy: ' + repr(self.healthy) + ' ' +\
 9599            'hostname: ' + repr(self.hostname) + ' ' +\
 9600            'id: ' + repr(self.id) + ' ' +\
 9601            'name: ' + repr(self.name) + ' ' +\
 9602            'password: ' + repr(self.password) + ' ' +\
 9603            'port: ' + repr(self.port) + ' ' +\
 9604            'port_override: ' + repr(self.port_override) + ' ' +\
 9605            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9606            'tags: ' + repr(self.tags) + ' ' +\
 9607            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9608            'username: ' + repr(self.username) + ' ' +\
 9609            '>'
 9610
 9611    def to_dict(self):
 9612        return {
 9613            'bind_interface': self.bind_interface,
 9614            'egress_filter': self.egress_filter,
 9615            'healthy': self.healthy,
 9616            'hostname': self.hostname,
 9617            'id': self.id,
 9618            'name': self.name,
 9619            'password': self.password,
 9620            'port': self.port,
 9621            'port_override': self.port_override,
 9622            'secret_store_id': self.secret_store_id,
 9623            'tags': self.tags,
 9624            'tls_required': self.tls_required,
 9625            'username': self.username,
 9626        }
 9627
 9628    @classmethod
 9629    def from_dict(cls, d):
 9630        return cls(
 9631            bind_interface=d.get('bind_interface'),
 9632            egress_filter=d.get('egress_filter'),
 9633            healthy=d.get('healthy'),
 9634            hostname=d.get('hostname'),
 9635            id=d.get('id'),
 9636            name=d.get('name'),
 9637            password=d.get('password'),
 9638            port=d.get('port'),
 9639            port_override=d.get('port_override'),
 9640            secret_store_id=d.get('secret_store_id'),
 9641            tags=d.get('tags'),
 9642            tls_required=d.get('tls_required'),
 9643            username=d.get('username'),
 9644        )
 9645
 9646
 9647class Redshift:
 9648    __slots__ = [
 9649        'bind_interface',
 9650        'database',
 9651        'egress_filter',
 9652        'healthy',
 9653        'hostname',
 9654        'id',
 9655        'name',
 9656        'override_database',
 9657        'password',
 9658        'port',
 9659        'port_override',
 9660        'secret_store_id',
 9661        'tags',
 9662        'username',
 9663    ]
 9664
 9665    def __init__(
 9666        self,
 9667        bind_interface=None,
 9668        database=None,
 9669        egress_filter=None,
 9670        healthy=None,
 9671        hostname=None,
 9672        id=None,
 9673        name=None,
 9674        override_database=None,
 9675        password=None,
 9676        port=None,
 9677        port_override=None,
 9678        secret_store_id=None,
 9679        tags=None,
 9680        username=None,
 9681    ):
 9682        self.bind_interface = bind_interface if bind_interface is not None else ''
 9683        '''
 9684         Bind interface
 9685        '''
 9686        self.database = database if database is not None else ''
 9687        self.egress_filter = egress_filter if egress_filter is not None else ''
 9688        '''
 9689         A filter applied to the routing logic to pin datasource to nodes.
 9690        '''
 9691        self.healthy = healthy if healthy is not None else False
 9692        '''
 9693         True if the datasource is reachable and the credentials are valid.
 9694        '''
 9695        self.hostname = hostname if hostname is not None else ''
 9696        self.id = id if id is not None else ''
 9697        '''
 9698         Unique identifier of the Resource.
 9699        '''
 9700        self.name = name if name is not None else ''
 9701        '''
 9702         Unique human-readable name of the Resource.
 9703        '''
 9704        self.override_database = override_database if override_database is not None else False
 9705        self.password = password if password is not None else ''
 9706        self.port = port if port is not None else 0
 9707        self.port_override = port_override if port_override is not None else 0
 9708        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9709        '''
 9710         ID of the secret store containing credentials for this resource, if any.
 9711        '''
 9712        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9713        '''
 9714         Tags is a map of key, value pairs.
 9715        '''
 9716        self.username = username if username is not None else ''
 9717
 9718    def __repr__(self):
 9719        return '<sdm.Redshift ' + \
 9720            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9721            'database: ' + repr(self.database) + ' ' +\
 9722            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9723            'healthy: ' + repr(self.healthy) + ' ' +\
 9724            'hostname: ' + repr(self.hostname) + ' ' +\
 9725            'id: ' + repr(self.id) + ' ' +\
 9726            'name: ' + repr(self.name) + ' ' +\
 9727            'override_database: ' + repr(self.override_database) + ' ' +\
 9728            'password: ' + repr(self.password) + ' ' +\
 9729            'port: ' + repr(self.port) + ' ' +\
 9730            'port_override: ' + repr(self.port_override) + ' ' +\
 9731            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9732            'tags: ' + repr(self.tags) + ' ' +\
 9733            'username: ' + repr(self.username) + ' ' +\
 9734            '>'
 9735
 9736    def to_dict(self):
 9737        return {
 9738            'bind_interface': self.bind_interface,
 9739            'database': self.database,
 9740            'egress_filter': self.egress_filter,
 9741            'healthy': self.healthy,
 9742            'hostname': self.hostname,
 9743            'id': self.id,
 9744            'name': self.name,
 9745            'override_database': self.override_database,
 9746            'password': self.password,
 9747            'port': self.port,
 9748            'port_override': self.port_override,
 9749            'secret_store_id': self.secret_store_id,
 9750            'tags': self.tags,
 9751            'username': self.username,
 9752        }
 9753
 9754    @classmethod
 9755    def from_dict(cls, d):
 9756        return cls(
 9757            bind_interface=d.get('bind_interface'),
 9758            database=d.get('database'),
 9759            egress_filter=d.get('egress_filter'),
 9760            healthy=d.get('healthy'),
 9761            hostname=d.get('hostname'),
 9762            id=d.get('id'),
 9763            name=d.get('name'),
 9764            override_database=d.get('override_database'),
 9765            password=d.get('password'),
 9766            port=d.get('port'),
 9767            port_override=d.get('port_override'),
 9768            secret_store_id=d.get('secret_store_id'),
 9769            tags=d.get('tags'),
 9770            username=d.get('username'),
 9771        )
 9772
 9773
 9774class Relay:
 9775    '''
 9776         Relay represents a StrongDM CLI installation running in relay mode.
 9777    '''
 9778    __slots__ = [
 9779        'device',
 9780        'gateway_filter',
 9781        'id',
 9782        'location',
 9783        'name',
 9784        'state',
 9785        'tags',
 9786        'version',
 9787    ]
 9788
 9789    def __init__(
 9790        self,
 9791        device=None,
 9792        gateway_filter=None,
 9793        id=None,
 9794        location=None,
 9795        name=None,
 9796        state=None,
 9797        tags=None,
 9798        version=None,
 9799    ):
 9800        self.device = device if device is not None else ''
 9801        '''
 9802         Device is a read only device name uploaded by the gateway process when 
 9803         it comes online.
 9804        '''
 9805        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
 9806        '''
 9807         GatewayFilter can be used to restrict the peering between relays and
 9808         gateways.
 9809        '''
 9810        self.id = id if id is not None else ''
 9811        '''
 9812         Unique identifier of the Relay.
 9813        '''
 9814        self.location = location if location is not None else ''
 9815        '''
 9816         Location is a read only network location uploaded by the gateway process
 9817         when it comes online.
 9818        '''
 9819        self.name = name if name is not None else ''
 9820        '''
 9821         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
 9822        '''
 9823        self.state = state if state is not None else ''
 9824        '''
 9825         The current state of the relay. One of: "new", "verifying_restart",
 9826         "awaiting_restart", "restarting", "started", "stopped", "dead",
 9827         "unknown".
 9828        '''
 9829        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9830        '''
 9831         Tags is a map of key, value pairs.
 9832        '''
 9833        self.version = version if version is not None else ''
 9834        '''
 9835         Version is a read only sdm binary version uploaded by the gateway process
 9836         when it comes online.
 9837        '''
 9838
 9839    def __repr__(self):
 9840        return '<sdm.Relay ' + \
 9841            'device: ' + repr(self.device) + ' ' +\
 9842            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
 9843            'id: ' + repr(self.id) + ' ' +\
 9844            'location: ' + repr(self.location) + ' ' +\
 9845            'name: ' + repr(self.name) + ' ' +\
 9846            'state: ' + repr(self.state) + ' ' +\
 9847            'tags: ' + repr(self.tags) + ' ' +\
 9848            'version: ' + repr(self.version) + ' ' +\
 9849            '>'
 9850
 9851    def to_dict(self):
 9852        return {
 9853            'device': self.device,
 9854            'gateway_filter': self.gateway_filter,
 9855            'id': self.id,
 9856            'location': self.location,
 9857            'name': self.name,
 9858            'state': self.state,
 9859            'tags': self.tags,
 9860            'version': self.version,
 9861        }
 9862
 9863    @classmethod
 9864    def from_dict(cls, d):
 9865        return cls(
 9866            device=d.get('device'),
 9867            gateway_filter=d.get('gateway_filter'),
 9868            id=d.get('id'),
 9869            location=d.get('location'),
 9870            name=d.get('name'),
 9871            state=d.get('state'),
 9872            tags=d.get('tags'),
 9873            version=d.get('version'),
 9874        )
 9875
 9876
 9877class RemoteIdentity:
 9878    '''
 9879         RemoteIdentities define the username to be used for a specific account
 9880     when connecting to a remote resource using that group.
 9881    '''
 9882    __slots__ = [
 9883        'account_id',
 9884        'id',
 9885        'remote_identity_group_id',
 9886        'username',
 9887    ]
 9888
 9889    def __init__(
 9890        self,
 9891        account_id=None,
 9892        id=None,
 9893        remote_identity_group_id=None,
 9894        username=None,
 9895    ):
 9896        self.account_id = account_id if account_id is not None else ''
 9897        '''
 9898         The account for this remote identity.
 9899        '''
 9900        self.id = id if id is not None else ''
 9901        '''
 9902         Unique identifier of the RemoteIdentity.
 9903        '''
 9904        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 9905        '''
 9906         The remote identity group.
 9907        '''
 9908        self.username = username if username is not None else ''
 9909        '''
 9910         The username to be used as the remote identity for this account.
 9911        '''
 9912
 9913    def __repr__(self):
 9914        return '<sdm.RemoteIdentity ' + \
 9915            'account_id: ' + repr(self.account_id) + ' ' +\
 9916            'id: ' + repr(self.id) + ' ' +\
 9917            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 9918            'username: ' + repr(self.username) + ' ' +\
 9919            '>'
 9920
 9921    def to_dict(self):
 9922        return {
 9923            'account_id': self.account_id,
 9924            'id': self.id,
 9925            'remote_identity_group_id': self.remote_identity_group_id,
 9926            'username': self.username,
 9927        }
 9928
 9929    @classmethod
 9930    def from_dict(cls, d):
 9931        return cls(
 9932            account_id=d.get('account_id'),
 9933            id=d.get('id'),
 9934            remote_identity_group_id=d.get('remote_identity_group_id'),
 9935            username=d.get('username'),
 9936        )
 9937
 9938
 9939class RemoteIdentityCreateResponse:
 9940    '''
 9941         RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.
 9942    '''
 9943    __slots__ = [
 9944        'meta',
 9945        'rate_limit',
 9946        'remote_identity',
 9947    ]
 9948
 9949    def __init__(
 9950        self,
 9951        meta=None,
 9952        rate_limit=None,
 9953        remote_identity=None,
 9954    ):
 9955        self.meta = meta if meta is not None else None
 9956        '''
 9957         Reserved for future use.
 9958        '''
 9959        self.rate_limit = rate_limit if rate_limit is not None else None
 9960        '''
 9961         Rate limit information.
 9962        '''
 9963        self.remote_identity = remote_identity if remote_identity is not None else None
 9964        '''
 9965         The created RemoteIdentity.
 9966        '''
 9967
 9968    def __repr__(self):
 9969        return '<sdm.RemoteIdentityCreateResponse ' + \
 9970            'meta: ' + repr(self.meta) + ' ' +\
 9971            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9972            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
 9973            '>'
 9974
 9975    def to_dict(self):
 9976        return {
 9977            'meta': self.meta,
 9978            'rate_limit': self.rate_limit,
 9979            'remote_identity': self.remote_identity,
 9980        }
 9981
 9982    @classmethod
 9983    def from_dict(cls, d):
 9984        return cls(
 9985            meta=d.get('meta'),
 9986            rate_limit=d.get('rate_limit'),
 9987            remote_identity=d.get('remote_identity'),
 9988        )
 9989
 9990
 9991class RemoteIdentityDeleteResponse:
 9992    '''
 9993         RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.
 9994    '''
 9995    __slots__ = [
 9996        'meta',
 9997        'rate_limit',
 9998    ]
 9999
10000    def __init__(
10001        self,
10002        meta=None,
10003        rate_limit=None,
10004    ):
10005        self.meta = meta if meta is not None else None
10006        '''
10007         Reserved for future use.
10008        '''
10009        self.rate_limit = rate_limit if rate_limit is not None else None
10010        '''
10011         Rate limit information.
10012        '''
10013
10014    def __repr__(self):
10015        return '<sdm.RemoteIdentityDeleteResponse ' + \
10016            'meta: ' + repr(self.meta) + ' ' +\
10017            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10018            '>'
10019
10020    def to_dict(self):
10021        return {
10022            'meta': self.meta,
10023            'rate_limit': self.rate_limit,
10024        }
10025
10026    @classmethod
10027    def from_dict(cls, d):
10028        return cls(
10029            meta=d.get('meta'),
10030            rate_limit=d.get('rate_limit'),
10031        )
10032
10033
10034class RemoteIdentityGetResponse:
10035    '''
10036         RemoteIdentityGetResponse returns a requested RemoteIdentity.
10037    '''
10038    __slots__ = [
10039        'meta',
10040        'rate_limit',
10041        'remote_identity',
10042    ]
10043
10044    def __init__(
10045        self,
10046        meta=None,
10047        rate_limit=None,
10048        remote_identity=None,
10049    ):
10050        self.meta = meta if meta is not None else None
10051        '''
10052         Reserved for future use.
10053        '''
10054        self.rate_limit = rate_limit if rate_limit is not None else None
10055        '''
10056         Rate limit information.
10057        '''
10058        self.remote_identity = remote_identity if remote_identity is not None else None
10059        '''
10060         The requested RemoteIdentity.
10061        '''
10062
10063    def __repr__(self):
10064        return '<sdm.RemoteIdentityGetResponse ' + \
10065            'meta: ' + repr(self.meta) + ' ' +\
10066            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10067            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10068            '>'
10069
10070    def to_dict(self):
10071        return {
10072            'meta': self.meta,
10073            'rate_limit': self.rate_limit,
10074            'remote_identity': self.remote_identity,
10075        }
10076
10077    @classmethod
10078    def from_dict(cls, d):
10079        return cls(
10080            meta=d.get('meta'),
10081            rate_limit=d.get('rate_limit'),
10082            remote_identity=d.get('remote_identity'),
10083        )
10084
10085
10086class RemoteIdentityGroup:
10087    '''
10088         A RemoteIdentityGroup defines a group of remote identities.
10089    '''
10090    __slots__ = [
10091        'id',
10092        'name',
10093    ]
10094
10095    def __init__(
10096        self,
10097        id=None,
10098        name=None,
10099    ):
10100        self.id = id if id is not None else ''
10101        '''
10102         Unique identifier of the RemoteIdentityGroup.
10103        '''
10104        self.name = name if name is not None else ''
10105        '''
10106         Unique human-readable name of the RemoteIdentityGroup.
10107        '''
10108
10109    def __repr__(self):
10110        return '<sdm.RemoteIdentityGroup ' + \
10111            'id: ' + repr(self.id) + ' ' +\
10112            'name: ' + repr(self.name) + ' ' +\
10113            '>'
10114
10115    def to_dict(self):
10116        return {
10117            'id': self.id,
10118            'name': self.name,
10119        }
10120
10121    @classmethod
10122    def from_dict(cls, d):
10123        return cls(
10124            id=d.get('id'),
10125            name=d.get('name'),
10126        )
10127
10128
10129class RemoteIdentityGroupGetResponse:
10130    '''
10131         RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.
10132    '''
10133    __slots__ = [
10134        'meta',
10135        'rate_limit',
10136        'remote_identity_group',
10137    ]
10138
10139    def __init__(
10140        self,
10141        meta=None,
10142        rate_limit=None,
10143        remote_identity_group=None,
10144    ):
10145        self.meta = meta if meta is not None else None
10146        '''
10147         Reserved for future use.
10148        '''
10149        self.rate_limit = rate_limit if rate_limit is not None else None
10150        '''
10151         Rate limit information.
10152        '''
10153        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10154        '''
10155         The requested RemoteIdentityGroup.
10156        '''
10157
10158    def __repr__(self):
10159        return '<sdm.RemoteIdentityGroupGetResponse ' + \
10160            'meta: ' + repr(self.meta) + ' ' +\
10161            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10162            'remote_identity_group: ' + repr(self.remote_identity_group) + ' ' +\
10163            '>'
10164
10165    def to_dict(self):
10166        return {
10167            'meta': self.meta,
10168            'rate_limit': self.rate_limit,
10169            'remote_identity_group': self.remote_identity_group,
10170        }
10171
10172    @classmethod
10173    def from_dict(cls, d):
10174        return cls(
10175            meta=d.get('meta'),
10176            rate_limit=d.get('rate_limit'),
10177            remote_identity_group=d.get('remote_identity_group'),
10178        )
10179
10180
10181class RemoteIdentityUpdateResponse:
10182    '''
10183         RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by
10184     a RemoteIdentityUpdateRequest.
10185    '''
10186    __slots__ = [
10187        'meta',
10188        'rate_limit',
10189        'remote_identity',
10190    ]
10191
10192    def __init__(
10193        self,
10194        meta=None,
10195        rate_limit=None,
10196        remote_identity=None,
10197    ):
10198        self.meta = meta if meta is not None else None
10199        '''
10200         Reserved for future use.
10201        '''
10202        self.rate_limit = rate_limit if rate_limit is not None else None
10203        '''
10204         Rate limit information.
10205        '''
10206        self.remote_identity = remote_identity if remote_identity is not None else None
10207        '''
10208         The updated RemoteIdentity.
10209        '''
10210
10211    def __repr__(self):
10212        return '<sdm.RemoteIdentityUpdateResponse ' + \
10213            'meta: ' + repr(self.meta) + ' ' +\
10214            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10215            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10216            '>'
10217
10218    def to_dict(self):
10219        return {
10220            'meta': self.meta,
10221            'rate_limit': self.rate_limit,
10222            'remote_identity': self.remote_identity,
10223        }
10224
10225    @classmethod
10226    def from_dict(cls, d):
10227        return cls(
10228            meta=d.get('meta'),
10229            rate_limit=d.get('rate_limit'),
10230            remote_identity=d.get('remote_identity'),
10231        )
10232
10233
10234class ResourceCreateResponse:
10235    '''
10236         ResourceCreateResponse reports how the Resources were created in the system.
10237    '''
10238    __slots__ = [
10239        'meta',
10240        'rate_limit',
10241        'resource',
10242    ]
10243
10244    def __init__(
10245        self,
10246        meta=None,
10247        rate_limit=None,
10248        resource=None,
10249    ):
10250        self.meta = meta if meta is not None else None
10251        '''
10252         Reserved for future use.
10253        '''
10254        self.rate_limit = rate_limit if rate_limit is not None else None
10255        '''
10256         Rate limit information.
10257        '''
10258        self.resource = resource if resource is not None else None
10259        '''
10260         The created Resource.
10261        '''
10262
10263    def __repr__(self):
10264        return '<sdm.ResourceCreateResponse ' + \
10265            'meta: ' + repr(self.meta) + ' ' +\
10266            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10267            'resource: ' + repr(self.resource) + ' ' +\
10268            '>'
10269
10270    def to_dict(self):
10271        return {
10272            'meta': self.meta,
10273            'rate_limit': self.rate_limit,
10274            'resource': self.resource,
10275        }
10276
10277    @classmethod
10278    def from_dict(cls, d):
10279        return cls(
10280            meta=d.get('meta'),
10281            rate_limit=d.get('rate_limit'),
10282            resource=d.get('resource'),
10283        )
10284
10285
10286class ResourceDeleteResponse:
10287    '''
10288         ResourceDeleteResponse returns information about a Resource that was deleted.
10289    '''
10290    __slots__ = [
10291        'meta',
10292        'rate_limit',
10293    ]
10294
10295    def __init__(
10296        self,
10297        meta=None,
10298        rate_limit=None,
10299    ):
10300        self.meta = meta if meta is not None else None
10301        '''
10302         Reserved for future use.
10303        '''
10304        self.rate_limit = rate_limit if rate_limit is not None else None
10305        '''
10306         Rate limit information.
10307        '''
10308
10309    def __repr__(self):
10310        return '<sdm.ResourceDeleteResponse ' + \
10311            'meta: ' + repr(self.meta) + ' ' +\
10312            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10313            '>'
10314
10315    def to_dict(self):
10316        return {
10317            'meta': self.meta,
10318            'rate_limit': self.rate_limit,
10319        }
10320
10321    @classmethod
10322    def from_dict(cls, d):
10323        return cls(
10324            meta=d.get('meta'),
10325            rate_limit=d.get('rate_limit'),
10326        )
10327
10328
10329class ResourceGetResponse:
10330    '''
10331         ResourceGetResponse returns a requested Resource.
10332    '''
10333    __slots__ = [
10334        'meta',
10335        'rate_limit',
10336        'resource',
10337    ]
10338
10339    def __init__(
10340        self,
10341        meta=None,
10342        rate_limit=None,
10343        resource=None,
10344    ):
10345        self.meta = meta if meta is not None else None
10346        '''
10347         Reserved for future use.
10348        '''
10349        self.rate_limit = rate_limit if rate_limit is not None else None
10350        '''
10351         Rate limit information.
10352        '''
10353        self.resource = resource if resource is not None else None
10354        '''
10355         The requested Resource.
10356        '''
10357
10358    def __repr__(self):
10359        return '<sdm.ResourceGetResponse ' + \
10360            'meta: ' + repr(self.meta) + ' ' +\
10361            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10362            'resource: ' + repr(self.resource) + ' ' +\
10363            '>'
10364
10365    def to_dict(self):
10366        return {
10367            'meta': self.meta,
10368            'rate_limit': self.rate_limit,
10369            'resource': self.resource,
10370        }
10371
10372    @classmethod
10373    def from_dict(cls, d):
10374        return cls(
10375            meta=d.get('meta'),
10376            rate_limit=d.get('rate_limit'),
10377            resource=d.get('resource'),
10378        )
10379
10380
10381class ResourceUpdateResponse:
10382    '''
10383         ResourceUpdateResponse returns the fields of a Resource after it has been updated by
10384     a ResourceUpdateRequest.
10385    '''
10386    __slots__ = [
10387        'meta',
10388        'rate_limit',
10389        'resource',
10390    ]
10391
10392    def __init__(
10393        self,
10394        meta=None,
10395        rate_limit=None,
10396        resource=None,
10397    ):
10398        self.meta = meta if meta is not None else None
10399        '''
10400         Reserved for future use.
10401        '''
10402        self.rate_limit = rate_limit if rate_limit is not None else None
10403        '''
10404         Rate limit information.
10405        '''
10406        self.resource = resource if resource is not None else None
10407        '''
10408         The updated Resource.
10409        '''
10410
10411    def __repr__(self):
10412        return '<sdm.ResourceUpdateResponse ' + \
10413            'meta: ' + repr(self.meta) + ' ' +\
10414            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10415            'resource: ' + repr(self.resource) + ' ' +\
10416            '>'
10417
10418    def to_dict(self):
10419        return {
10420            'meta': self.meta,
10421            'rate_limit': self.rate_limit,
10422            'resource': self.resource,
10423        }
10424
10425    @classmethod
10426    def from_dict(cls, d):
10427        return cls(
10428            meta=d.get('meta'),
10429            rate_limit=d.get('rate_limit'),
10430            resource=d.get('resource'),
10431        )
10432
10433
10434class Role:
10435    '''
10436         A Role has a list of access rules which determine which Resources the members
10437     of the Role have access to. An Account can be a member of multiple Roles via
10438     AccountAttachments.
10439    '''
10440    __slots__ = [
10441        'access_rules',
10442        'id',
10443        'managed_by',
10444        'name',
10445        'tags',
10446    ]
10447
10448    def __init__(
10449        self,
10450        access_rules=None,
10451        id=None,
10452        managed_by=None,
10453        name=None,
10454        tags=None,
10455    ):
10456        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
10457        )
10458        '''
10459         AccessRules is a list of access rules defining the resources this Role has access to.
10460        '''
10461        self.id = id if id is not None else ''
10462        '''
10463         Unique identifier of the Role.
10464        '''
10465        self.managed_by = managed_by if managed_by is not None else ''
10466        '''
10467         Managed By is a read only field for what service manages this role, e.g. StrongDM, Okta, Azure.
10468        '''
10469        self.name = name if name is not None else ''
10470        '''
10471         Unique human-readable name of the Role.
10472        '''
10473        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10474        '''
10475         Tags is a map of key, value pairs.
10476        '''
10477
10478    def __repr__(self):
10479        return '<sdm.Role ' + \
10480            'access_rules: ' + repr(self.access_rules) + ' ' +\
10481            'id: ' + repr(self.id) + ' ' +\
10482            'managed_by: ' + repr(self.managed_by) + ' ' +\
10483            'name: ' + repr(self.name) + ' ' +\
10484            'tags: ' + repr(self.tags) + ' ' +\
10485            '>'
10486
10487    def to_dict(self):
10488        return {
10489            'access_rules': self.access_rules,
10490            'id': self.id,
10491            'managed_by': self.managed_by,
10492            'name': self.name,
10493            'tags': self.tags,
10494        }
10495
10496    @classmethod
10497    def from_dict(cls, d):
10498        return cls(
10499            access_rules=d.get('access_rules'),
10500            id=d.get('id'),
10501            managed_by=d.get('managed_by'),
10502            name=d.get('name'),
10503            tags=d.get('tags'),
10504        )
10505
10506
10507class RoleCreateResponse:
10508    '''
10509         RoleCreateResponse reports how the Roles were created in the system. It can
10510     communicate partial successes or failures.
10511    '''
10512    __slots__ = [
10513        'meta',
10514        'rate_limit',
10515        'role',
10516    ]
10517
10518    def __init__(
10519        self,
10520        meta=None,
10521        rate_limit=None,
10522        role=None,
10523    ):
10524        self.meta = meta if meta is not None else None
10525        '''
10526         Reserved for future use.
10527        '''
10528        self.rate_limit = rate_limit if rate_limit is not None else None
10529        '''
10530         Rate limit information.
10531        '''
10532        self.role = role if role is not None else None
10533        '''
10534         The created Role.
10535        '''
10536
10537    def __repr__(self):
10538        return '<sdm.RoleCreateResponse ' + \
10539            'meta: ' + repr(self.meta) + ' ' +\
10540            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10541            'role: ' + repr(self.role) + ' ' +\
10542            '>'
10543
10544    def to_dict(self):
10545        return {
10546            'meta': self.meta,
10547            'rate_limit': self.rate_limit,
10548            'role': self.role,
10549        }
10550
10551    @classmethod
10552    def from_dict(cls, d):
10553        return cls(
10554            meta=d.get('meta'),
10555            rate_limit=d.get('rate_limit'),
10556            role=d.get('role'),
10557        )
10558
10559
10560class RoleDeleteResponse:
10561    '''
10562         RoleDeleteResponse returns information about a Role that was deleted.
10563    '''
10564    __slots__ = [
10565        'meta',
10566        'rate_limit',
10567    ]
10568
10569    def __init__(
10570        self,
10571        meta=None,
10572        rate_limit=None,
10573    ):
10574        self.meta = meta if meta is not None else None
10575        '''
10576         Reserved for future use.
10577        '''
10578        self.rate_limit = rate_limit if rate_limit is not None else None
10579        '''
10580         Rate limit information.
10581        '''
10582
10583    def __repr__(self):
10584        return '<sdm.RoleDeleteResponse ' + \
10585            'meta: ' + repr(self.meta) + ' ' +\
10586            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10587            '>'
10588
10589    def to_dict(self):
10590        return {
10591            'meta': self.meta,
10592            'rate_limit': self.rate_limit,
10593        }
10594
10595    @classmethod
10596    def from_dict(cls, d):
10597        return cls(
10598            meta=d.get('meta'),
10599            rate_limit=d.get('rate_limit'),
10600        )
10601
10602
10603class RoleGetResponse:
10604    '''
10605         RoleGetResponse returns a requested Role.
10606    '''
10607    __slots__ = [
10608        'meta',
10609        'rate_limit',
10610        'role',
10611    ]
10612
10613    def __init__(
10614        self,
10615        meta=None,
10616        rate_limit=None,
10617        role=None,
10618    ):
10619        self.meta = meta if meta is not None else None
10620        '''
10621         Reserved for future use.
10622        '''
10623        self.rate_limit = rate_limit if rate_limit is not None else None
10624        '''
10625         Rate limit information.
10626        '''
10627        self.role = role if role is not None else None
10628        '''
10629         The requested Role.
10630        '''
10631
10632    def __repr__(self):
10633        return '<sdm.RoleGetResponse ' + \
10634            'meta: ' + repr(self.meta) + ' ' +\
10635            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10636            'role: ' + repr(self.role) + ' ' +\
10637            '>'
10638
10639    def to_dict(self):
10640        return {
10641            'meta': self.meta,
10642            'rate_limit': self.rate_limit,
10643            'role': self.role,
10644        }
10645
10646    @classmethod
10647    def from_dict(cls, d):
10648        return cls(
10649            meta=d.get('meta'),
10650            rate_limit=d.get('rate_limit'),
10651            role=d.get('role'),
10652        )
10653
10654
10655class RoleUpdateResponse:
10656    '''
10657         RoleUpdateResponse returns the fields of a Role after it has been updated by
10658     a RoleUpdateRequest.
10659    '''
10660    __slots__ = [
10661        'meta',
10662        'rate_limit',
10663        'role',
10664    ]
10665
10666    def __init__(
10667        self,
10668        meta=None,
10669        rate_limit=None,
10670        role=None,
10671    ):
10672        self.meta = meta if meta is not None else None
10673        '''
10674         Reserved for future use.
10675        '''
10676        self.rate_limit = rate_limit if rate_limit is not None else None
10677        '''
10678         Rate limit information.
10679        '''
10680        self.role = role if role is not None else None
10681        '''
10682         The updated Role.
10683        '''
10684
10685    def __repr__(self):
10686        return '<sdm.RoleUpdateResponse ' + \
10687            'meta: ' + repr(self.meta) + ' ' +\
10688            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10689            'role: ' + repr(self.role) + ' ' +\
10690            '>'
10691
10692    def to_dict(self):
10693        return {
10694            'meta': self.meta,
10695            'rate_limit': self.rate_limit,
10696            'role': self.role,
10697        }
10698
10699    @classmethod
10700    def from_dict(cls, d):
10701        return cls(
10702            meta=d.get('meta'),
10703            rate_limit=d.get('rate_limit'),
10704            role=d.get('role'),
10705        )
10706
10707
10708class SQLServer:
10709    __slots__ = [
10710        'bind_interface',
10711        'database',
10712        'egress_filter',
10713        'healthy',
10714        'hostname',
10715        'id',
10716        'name',
10717        'override_database',
10718        'password',
10719        'port',
10720        'port_override',
10721        'schema',
10722        'secret_store_id',
10723        'tags',
10724        'username',
10725    ]
10726
10727    def __init__(
10728        self,
10729        bind_interface=None,
10730        database=None,
10731        egress_filter=None,
10732        healthy=None,
10733        hostname=None,
10734        id=None,
10735        name=None,
10736        override_database=None,
10737        password=None,
10738        port=None,
10739        port_override=None,
10740        schema=None,
10741        secret_store_id=None,
10742        tags=None,
10743        username=None,
10744    ):
10745        self.bind_interface = bind_interface if bind_interface is not None else ''
10746        '''
10747         Bind interface
10748        '''
10749        self.database = database if database is not None else ''
10750        self.egress_filter = egress_filter if egress_filter is not None else ''
10751        '''
10752         A filter applied to the routing logic to pin datasource to nodes.
10753        '''
10754        self.healthy = healthy if healthy is not None else False
10755        '''
10756         True if the datasource is reachable and the credentials are valid.
10757        '''
10758        self.hostname = hostname if hostname is not None else ''
10759        self.id = id if id is not None else ''
10760        '''
10761         Unique identifier of the Resource.
10762        '''
10763        self.name = name if name is not None else ''
10764        '''
10765         Unique human-readable name of the Resource.
10766        '''
10767        self.override_database = override_database if override_database is not None else False
10768        self.password = password if password is not None else ''
10769        self.port = port if port is not None else 0
10770        self.port_override = port_override if port_override is not None else 0
10771        self.schema = schema if schema is not None else ''
10772        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10773        '''
10774         ID of the secret store containing credentials for this resource, if any.
10775        '''
10776        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10777        '''
10778         Tags is a map of key, value pairs.
10779        '''
10780        self.username = username if username is not None else ''
10781
10782    def __repr__(self):
10783        return '<sdm.SQLServer ' + \
10784            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10785            'database: ' + repr(self.database) + ' ' +\
10786            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10787            'healthy: ' + repr(self.healthy) + ' ' +\
10788            'hostname: ' + repr(self.hostname) + ' ' +\
10789            'id: ' + repr(self.id) + ' ' +\
10790            'name: ' + repr(self.name) + ' ' +\
10791            'override_database: ' + repr(self.override_database) + ' ' +\
10792            'password: ' + repr(self.password) + ' ' +\
10793            'port: ' + repr(self.port) + ' ' +\
10794            'port_override: ' + repr(self.port_override) + ' ' +\
10795            'schema: ' + repr(self.schema) + ' ' +\
10796            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10797            'tags: ' + repr(self.tags) + ' ' +\
10798            'username: ' + repr(self.username) + ' ' +\
10799            '>'
10800
10801    def to_dict(self):
10802        return {
10803            'bind_interface': self.bind_interface,
10804            'database': self.database,
10805            'egress_filter': self.egress_filter,
10806            'healthy': self.healthy,
10807            'hostname': self.hostname,
10808            'id': self.id,
10809            'name': self.name,
10810            'override_database': self.override_database,
10811            'password': self.password,
10812            'port': self.port,
10813            'port_override': self.port_override,
10814            'schema': self.schema,
10815            'secret_store_id': self.secret_store_id,
10816            'tags': self.tags,
10817            'username': self.username,
10818        }
10819
10820    @classmethod
10821    def from_dict(cls, d):
10822        return cls(
10823            bind_interface=d.get('bind_interface'),
10824            database=d.get('database'),
10825            egress_filter=d.get('egress_filter'),
10826            healthy=d.get('healthy'),
10827            hostname=d.get('hostname'),
10828            id=d.get('id'),
10829            name=d.get('name'),
10830            override_database=d.get('override_database'),
10831            password=d.get('password'),
10832            port=d.get('port'),
10833            port_override=d.get('port_override'),
10834            schema=d.get('schema'),
10835            secret_store_id=d.get('secret_store_id'),
10836            tags=d.get('tags'),
10837            username=d.get('username'),
10838        )
10839
10840
10841class SSH:
10842    __slots__ = [
10843        'allow_deprecated_key_exchanges',
10844        'bind_interface',
10845        'egress_filter',
10846        'healthy',
10847        'hostname',
10848        'id',
10849        'key_type',
10850        'name',
10851        'port',
10852        'port_forwarding',
10853        'port_override',
10854        'public_key',
10855        'secret_store_id',
10856        'tags',
10857        'username',
10858    ]
10859
10860    def __init__(
10861        self,
10862        allow_deprecated_key_exchanges=None,
10863        bind_interface=None,
10864        egress_filter=None,
10865        healthy=None,
10866        hostname=None,
10867        id=None,
10868        key_type=None,
10869        name=None,
10870        port=None,
10871        port_forwarding=None,
10872        port_override=None,
10873        public_key=None,
10874        secret_store_id=None,
10875        tags=None,
10876        username=None,
10877    ):
10878        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10879        self.bind_interface = bind_interface if bind_interface is not None else ''
10880        '''
10881         Bind interface
10882        '''
10883        self.egress_filter = egress_filter if egress_filter is not None else ''
10884        '''
10885         A filter applied to the routing logic to pin datasource to nodes.
10886        '''
10887        self.healthy = healthy if healthy is not None else False
10888        '''
10889         True if the datasource is reachable and the credentials are valid.
10890        '''
10891        self.hostname = hostname if hostname is not None else ''
10892        self.id = id if id is not None else ''
10893        '''
10894         Unique identifier of the Resource.
10895        '''
10896        self.key_type = key_type if key_type is not None else ''
10897        self.name = name if name is not None else ''
10898        '''
10899         Unique human-readable name of the Resource.
10900        '''
10901        self.port = port if port is not None else 0
10902        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10903        self.port_override = port_override if port_override is not None else 0
10904        self.public_key = public_key if public_key is not None else ''
10905        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10906        '''
10907         ID of the secret store containing credentials for this resource, if any.
10908        '''
10909        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10910        '''
10911         Tags is a map of key, value pairs.
10912        '''
10913        self.username = username if username is not None else ''
10914
10915    def __repr__(self):
10916        return '<sdm.SSH ' + \
10917            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10918            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10919            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10920            'healthy: ' + repr(self.healthy) + ' ' +\
10921            'hostname: ' + repr(self.hostname) + ' ' +\
10922            'id: ' + repr(self.id) + ' ' +\
10923            'key_type: ' + repr(self.key_type) + ' ' +\
10924            'name: ' + repr(self.name) + ' ' +\
10925            'port: ' + repr(self.port) + ' ' +\
10926            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10927            'port_override: ' + repr(self.port_override) + ' ' +\
10928            'public_key: ' + repr(self.public_key) + ' ' +\
10929            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10930            'tags: ' + repr(self.tags) + ' ' +\
10931            'username: ' + repr(self.username) + ' ' +\
10932            '>'
10933
10934    def to_dict(self):
10935        return {
10936            'allow_deprecated_key_exchanges':
10937            self.allow_deprecated_key_exchanges,
10938            'bind_interface': self.bind_interface,
10939            'egress_filter': self.egress_filter,
10940            'healthy': self.healthy,
10941            'hostname': self.hostname,
10942            'id': self.id,
10943            'key_type': self.key_type,
10944            'name': self.name,
10945            'port': self.port,
10946            'port_forwarding': self.port_forwarding,
10947            'port_override': self.port_override,
10948            'public_key': self.public_key,
10949            'secret_store_id': self.secret_store_id,
10950            'tags': self.tags,
10951            'username': self.username,
10952        }
10953
10954    @classmethod
10955    def from_dict(cls, d):
10956        return cls(
10957            allow_deprecated_key_exchanges=d.get(
10958                'allow_deprecated_key_exchanges'),
10959            bind_interface=d.get('bind_interface'),
10960            egress_filter=d.get('egress_filter'),
10961            healthy=d.get('healthy'),
10962            hostname=d.get('hostname'),
10963            id=d.get('id'),
10964            key_type=d.get('key_type'),
10965            name=d.get('name'),
10966            port=d.get('port'),
10967            port_forwarding=d.get('port_forwarding'),
10968            port_override=d.get('port_override'),
10969            public_key=d.get('public_key'),
10970            secret_store_id=d.get('secret_store_id'),
10971            tags=d.get('tags'),
10972            username=d.get('username'),
10973        )
10974
10975
10976class SSHCert:
10977    __slots__ = [
10978        'allow_deprecated_key_exchanges',
10979        'bind_interface',
10980        'egress_filter',
10981        'healthy',
10982        'hostname',
10983        'id',
10984        'key_type',
10985        'name',
10986        'port',
10987        'port_forwarding',
10988        'port_override',
10989        'remote_identity_group_id',
10990        'remote_identity_healthcheck_username',
10991        'secret_store_id',
10992        'tags',
10993        'username',
10994    ]
10995
10996    def __init__(
10997        self,
10998        allow_deprecated_key_exchanges=None,
10999        bind_interface=None,
11000        egress_filter=None,
11001        healthy=None,
11002        hostname=None,
11003        id=None,
11004        key_type=None,
11005        name=None,
11006        port=None,
11007        port_forwarding=None,
11008        port_override=None,
11009        remote_identity_group_id=None,
11010        remote_identity_healthcheck_username=None,
11011        secret_store_id=None,
11012        tags=None,
11013        username=None,
11014    ):
11015        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11016        self.bind_interface = bind_interface if bind_interface is not None else ''
11017        '''
11018         Bind interface
11019        '''
11020        self.egress_filter = egress_filter if egress_filter is not None else ''
11021        '''
11022         A filter applied to the routing logic to pin datasource to nodes.
11023        '''
11024        self.healthy = healthy if healthy is not None else False
11025        '''
11026         True if the datasource is reachable and the credentials are valid.
11027        '''
11028        self.hostname = hostname if hostname is not None else ''
11029        self.id = id if id is not None else ''
11030        '''
11031         Unique identifier of the Resource.
11032        '''
11033        self.key_type = key_type if key_type is not None else ''
11034        self.name = name if name is not None else ''
11035        '''
11036         Unique human-readable name of the Resource.
11037        '''
11038        self.port = port if port is not None else 0
11039        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11040        self.port_override = port_override if port_override is not None else 0
11041        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
11042        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
11043        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11044        '''
11045         ID of the secret store containing credentials for this resource, if any.
11046        '''
11047        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11048        '''
11049         Tags is a map of key, value pairs.
11050        '''
11051        self.username = username if username is not None else ''
11052
11053    def __repr__(self):
11054        return '<sdm.SSHCert ' + \
11055            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11056            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11057            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11058            'healthy: ' + repr(self.healthy) + ' ' +\
11059            'hostname: ' + repr(self.hostname) + ' ' +\
11060            'id: ' + repr(self.id) + ' ' +\
11061            'key_type: ' + repr(self.key_type) + ' ' +\
11062            'name: ' + repr(self.name) + ' ' +\
11063            'port: ' + repr(self.port) + ' ' +\
11064            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11065            'port_override: ' + repr(self.port_override) + ' ' +\
11066            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
11067            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
11068            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11069            'tags: ' + repr(self.tags) + ' ' +\
11070            'username: ' + repr(self.username) + ' ' +\
11071            '>'
11072
11073    def to_dict(self):
11074        return {
11075            'allow_deprecated_key_exchanges':
11076            self.allow_deprecated_key_exchanges,
11077            'bind_interface': self.bind_interface,
11078            'egress_filter': self.egress_filter,
11079            'healthy': self.healthy,
11080            'hostname': self.hostname,
11081            'id': self.id,
11082            'key_type': self.key_type,
11083            'name': self.name,
11084            'port': self.port,
11085            'port_forwarding': self.port_forwarding,
11086            'port_override': self.port_override,
11087            'remote_identity_group_id': self.remote_identity_group_id,
11088            'remote_identity_healthcheck_username':
11089            self.remote_identity_healthcheck_username,
11090            'secret_store_id': self.secret_store_id,
11091            'tags': self.tags,
11092            'username': self.username,
11093        }
11094
11095    @classmethod
11096    def from_dict(cls, d):
11097        return cls(
11098            allow_deprecated_key_exchanges=d.get(
11099                'allow_deprecated_key_exchanges'),
11100            bind_interface=d.get('bind_interface'),
11101            egress_filter=d.get('egress_filter'),
11102            healthy=d.get('healthy'),
11103            hostname=d.get('hostname'),
11104            id=d.get('id'),
11105            key_type=d.get('key_type'),
11106            name=d.get('name'),
11107            port=d.get('port'),
11108            port_forwarding=d.get('port_forwarding'),
11109            port_override=d.get('port_override'),
11110            remote_identity_group_id=d.get('remote_identity_group_id'),
11111            remote_identity_healthcheck_username=d.get(
11112                'remote_identity_healthcheck_username'),
11113            secret_store_id=d.get('secret_store_id'),
11114            tags=d.get('tags'),
11115            username=d.get('username'),
11116        )
11117
11118
11119class SSHCustomerKey:
11120    __slots__ = [
11121        'allow_deprecated_key_exchanges',
11122        'bind_interface',
11123        'egress_filter',
11124        'healthy',
11125        'hostname',
11126        'id',
11127        'name',
11128        'port',
11129        'port_forwarding',
11130        'port_override',
11131        'private_key',
11132        'secret_store_id',
11133        'tags',
11134        'username',
11135    ]
11136
11137    def __init__(
11138        self,
11139        allow_deprecated_key_exchanges=None,
11140        bind_interface=None,
11141        egress_filter=None,
11142        healthy=None,
11143        hostname=None,
11144        id=None,
11145        name=None,
11146        port=None,
11147        port_forwarding=None,
11148        port_override=None,
11149        private_key=None,
11150        secret_store_id=None,
11151        tags=None,
11152        username=None,
11153    ):
11154        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11155        self.bind_interface = bind_interface if bind_interface is not None else ''
11156        '''
11157         Bind interface
11158        '''
11159        self.egress_filter = egress_filter if egress_filter is not None else ''
11160        '''
11161         A filter applied to the routing logic to pin datasource to nodes.
11162        '''
11163        self.healthy = healthy if healthy is not None else False
11164        '''
11165         True if the datasource is reachable and the credentials are valid.
11166        '''
11167        self.hostname = hostname if hostname is not None else ''
11168        self.id = id if id is not None else ''
11169        '''
11170         Unique identifier of the Resource.
11171        '''
11172        self.name = name if name is not None else ''
11173        '''
11174         Unique human-readable name of the Resource.
11175        '''
11176        self.port = port if port is not None else 0
11177        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11178        self.port_override = port_override if port_override is not None else 0
11179        self.private_key = private_key if private_key is not None else ''
11180        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11181        '''
11182         ID of the secret store containing credentials for this resource, if any.
11183        '''
11184        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11185        '''
11186         Tags is a map of key, value pairs.
11187        '''
11188        self.username = username if username is not None else ''
11189
11190    def __repr__(self):
11191        return '<sdm.SSHCustomerKey ' + \
11192            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11193            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11194            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11195            'healthy: ' + repr(self.healthy) + ' ' +\
11196            'hostname: ' + repr(self.hostname) + ' ' +\
11197            'id: ' + repr(self.id) + ' ' +\
11198            'name: ' + repr(self.name) + ' ' +\
11199            'port: ' + repr(self.port) + ' ' +\
11200            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11201            'port_override: ' + repr(self.port_override) + ' ' +\
11202            'private_key: ' + repr(self.private_key) + ' ' +\
11203            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11204            'tags: ' + repr(self.tags) + ' ' +\
11205            'username: ' + repr(self.username) + ' ' +\
11206            '>'
11207
11208    def to_dict(self):
11209        return {
11210            'allow_deprecated_key_exchanges':
11211            self.allow_deprecated_key_exchanges,
11212            'bind_interface': self.bind_interface,
11213            'egress_filter': self.egress_filter,
11214            'healthy': self.healthy,
11215            'hostname': self.hostname,
11216            'id': self.id,
11217            'name': self.name,
11218            'port': self.port,
11219            'port_forwarding': self.port_forwarding,
11220            'port_override': self.port_override,
11221            'private_key': self.private_key,
11222            'secret_store_id': self.secret_store_id,
11223            'tags': self.tags,
11224            'username': self.username,
11225        }
11226
11227    @classmethod
11228    def from_dict(cls, d):
11229        return cls(
11230            allow_deprecated_key_exchanges=d.get(
11231                'allow_deprecated_key_exchanges'),
11232            bind_interface=d.get('bind_interface'),
11233            egress_filter=d.get('egress_filter'),
11234            healthy=d.get('healthy'),
11235            hostname=d.get('hostname'),
11236            id=d.get('id'),
11237            name=d.get('name'),
11238            port=d.get('port'),
11239            port_forwarding=d.get('port_forwarding'),
11240            port_override=d.get('port_override'),
11241            private_key=d.get('private_key'),
11242            secret_store_id=d.get('secret_store_id'),
11243            tags=d.get('tags'),
11244            username=d.get('username'),
11245        )
11246
11247
11248class SecretStoreCreateResponse:
11249    '''
11250         SecretStoreCreateResponse reports how the SecretStores were created in the system.
11251    '''
11252    __slots__ = [
11253        'meta',
11254        'rate_limit',
11255        'secret_store',
11256    ]
11257
11258    def __init__(
11259        self,
11260        meta=None,
11261        rate_limit=None,
11262        secret_store=None,
11263    ):
11264        self.meta = meta if meta is not None else None
11265        '''
11266         Reserved for future use.
11267        '''
11268        self.rate_limit = rate_limit if rate_limit is not None else None
11269        '''
11270         Rate limit information.
11271        '''
11272        self.secret_store = secret_store if secret_store is not None else None
11273        '''
11274         The created SecretStore.
11275        '''
11276
11277    def __repr__(self):
11278        return '<sdm.SecretStoreCreateResponse ' + \
11279            'meta: ' + repr(self.meta) + ' ' +\
11280            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11281            'secret_store: ' + repr(self.secret_store) + ' ' +\
11282            '>'
11283
11284    def to_dict(self):
11285        return {
11286            'meta': self.meta,
11287            'rate_limit': self.rate_limit,
11288            'secret_store': self.secret_store,
11289        }
11290
11291    @classmethod
11292    def from_dict(cls, d):
11293        return cls(
11294            meta=d.get('meta'),
11295            rate_limit=d.get('rate_limit'),
11296            secret_store=d.get('secret_store'),
11297        )
11298
11299
11300class SecretStoreDeleteResponse:
11301    '''
11302         SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
11303    '''
11304    __slots__ = [
11305        'meta',
11306        'rate_limit',
11307    ]
11308
11309    def __init__(
11310        self,
11311        meta=None,
11312        rate_limit=None,
11313    ):
11314        self.meta = meta if meta is not None else None
11315        '''
11316         Reserved for future use.
11317        '''
11318        self.rate_limit = rate_limit if rate_limit is not None else None
11319        '''
11320         Rate limit information.
11321        '''
11322
11323    def __repr__(self):
11324        return '<sdm.SecretStoreDeleteResponse ' + \
11325            'meta: ' + repr(self.meta) + ' ' +\
11326            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11327            '>'
11328
11329    def to_dict(self):
11330        return {
11331            'meta': self.meta,
11332            'rate_limit': self.rate_limit,
11333        }
11334
11335    @classmethod
11336    def from_dict(cls, d):
11337        return cls(
11338            meta=d.get('meta'),
11339            rate_limit=d.get('rate_limit'),
11340        )
11341
11342
11343class SecretStoreGetResponse:
11344    '''
11345         SecretStoreGetResponse returns a requested SecretStore.
11346    '''
11347    __slots__ = [
11348        'meta',
11349        'rate_limit',
11350        'secret_store',
11351    ]
11352
11353    def __init__(
11354        self,
11355        meta=None,
11356        rate_limit=None,
11357        secret_store=None,
11358    ):
11359        self.meta = meta if meta is not None else None
11360        '''
11361         Reserved for future use.
11362        '''
11363        self.rate_limit = rate_limit if rate_limit is not None else None
11364        '''
11365         Rate limit information.
11366        '''
11367        self.secret_store = secret_store if secret_store is not None else None
11368        '''
11369         The requested SecretStore.
11370        '''
11371
11372    def __repr__(self):
11373        return '<sdm.SecretStoreGetResponse ' + \
11374            'meta: ' + repr(self.meta) + ' ' +\
11375            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11376            'secret_store: ' + repr(self.secret_store) + ' ' +\
11377            '>'
11378
11379    def to_dict(self):
11380        return {
11381            'meta': self.meta,
11382            'rate_limit': self.rate_limit,
11383            'secret_store': self.secret_store,
11384        }
11385
11386    @classmethod
11387    def from_dict(cls, d):
11388        return cls(
11389            meta=d.get('meta'),
11390            rate_limit=d.get('rate_limit'),
11391            secret_store=d.get('secret_store'),
11392        )
11393
11394
11395class SecretStoreUpdateResponse:
11396    '''
11397         SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
11398     a SecretStoreUpdateRequest.
11399    '''
11400    __slots__ = [
11401        'meta',
11402        'rate_limit',
11403        'secret_store',
11404    ]
11405
11406    def __init__(
11407        self,
11408        meta=None,
11409        rate_limit=None,
11410        secret_store=None,
11411    ):
11412        self.meta = meta if meta is not None else None
11413        '''
11414         Reserved for future use.
11415        '''
11416        self.rate_limit = rate_limit if rate_limit is not None else None
11417        '''
11418         Rate limit information.
11419        '''
11420        self.secret_store = secret_store if secret_store is not None else None
11421        '''
11422         The updated SecretStore.
11423        '''
11424
11425    def __repr__(self):
11426        return '<sdm.SecretStoreUpdateResponse ' + \
11427            'meta: ' + repr(self.meta) + ' ' +\
11428            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11429            'secret_store: ' + repr(self.secret_store) + ' ' +\
11430            '>'
11431
11432    def to_dict(self):
11433        return {
11434            'meta': self.meta,
11435            'rate_limit': self.rate_limit,
11436            'secret_store': self.secret_store,
11437        }
11438
11439    @classmethod
11440    def from_dict(cls, d):
11441        return cls(
11442            meta=d.get('meta'),
11443            rate_limit=d.get('rate_limit'),
11444            secret_store=d.get('secret_store'),
11445        )
11446
11447
11448class Service:
11449    '''
11450         A Service is a service account that can connect to resources they are granted
11451     directly, or granted via roles. Services are typically automated jobs.
11452    '''
11453    __slots__ = [
11454        'id',
11455        'name',
11456        'suspended',
11457        'tags',
11458    ]
11459
11460    def __init__(
11461        self,
11462        id=None,
11463        name=None,
11464        suspended=None,
11465        tags=None,
11466    ):
11467        self.id = id if id is not None else ''
11468        '''
11469         Unique identifier of the Service.
11470        '''
11471        self.name = name if name is not None else ''
11472        '''
11473         Unique human-readable name of the Service.
11474        '''
11475        self.suspended = suspended if suspended is not None else False
11476        '''
11477         The Service's suspended state.
11478        '''
11479        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11480        '''
11481         Tags is a map of key, value pairs.
11482        '''
11483
11484    def __repr__(self):
11485        return '<sdm.Service ' + \
11486            'id: ' + repr(self.id) + ' ' +\
11487            'name: ' + repr(self.name) + ' ' +\
11488            'suspended: ' + repr(self.suspended) + ' ' +\
11489            'tags: ' + repr(self.tags) + ' ' +\
11490            '>'
11491
11492    def to_dict(self):
11493        return {
11494            'id': self.id,
11495            'name': self.name,
11496            'suspended': self.suspended,
11497            'tags': self.tags,
11498        }
11499
11500    @classmethod
11501    def from_dict(cls, d):
11502        return cls(
11503            id=d.get('id'),
11504            name=d.get('name'),
11505            suspended=d.get('suspended'),
11506            tags=d.get('tags'),
11507        )
11508
11509
11510class SingleStore:
11511    __slots__ = [
11512        'bind_interface',
11513        'database',
11514        'egress_filter',
11515        'healthy',
11516        'hostname',
11517        'id',
11518        'name',
11519        'password',
11520        'port',
11521        'port_override',
11522        'secret_store_id',
11523        'tags',
11524        'username',
11525    ]
11526
11527    def __init__(
11528        self,
11529        bind_interface=None,
11530        database=None,
11531        egress_filter=None,
11532        healthy=None,
11533        hostname=None,
11534        id=None,
11535        name=None,
11536        password=None,
11537        port=None,
11538        port_override=None,
11539        secret_store_id=None,
11540        tags=None,
11541        username=None,
11542    ):
11543        self.bind_interface = bind_interface if bind_interface is not None else ''
11544        '''
11545         Bind interface
11546        '''
11547        self.database = database if database is not None else ''
11548        self.egress_filter = egress_filter if egress_filter is not None else ''
11549        '''
11550         A filter applied to the routing logic to pin datasource to nodes.
11551        '''
11552        self.healthy = healthy if healthy is not None else False
11553        '''
11554         True if the datasource is reachable and the credentials are valid.
11555        '''
11556        self.hostname = hostname if hostname is not None else ''
11557        self.id = id if id is not None else ''
11558        '''
11559         Unique identifier of the Resource.
11560        '''
11561        self.name = name if name is not None else ''
11562        '''
11563         Unique human-readable name of the Resource.
11564        '''
11565        self.password = password if password is not None else ''
11566        self.port = port if port is not None else 0
11567        self.port_override = port_override if port_override is not None else 0
11568        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11569        '''
11570         ID of the secret store containing credentials for this resource, if any.
11571        '''
11572        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11573        '''
11574         Tags is a map of key, value pairs.
11575        '''
11576        self.username = username if username is not None else ''
11577
11578    def __repr__(self):
11579        return '<sdm.SingleStore ' + \
11580            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11581            'database: ' + repr(self.database) + ' ' +\
11582            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11583            'healthy: ' + repr(self.healthy) + ' ' +\
11584            'hostname: ' + repr(self.hostname) + ' ' +\
11585            'id: ' + repr(self.id) + ' ' +\
11586            'name: ' + repr(self.name) + ' ' +\
11587            'password: ' + repr(self.password) + ' ' +\
11588            'port: ' + repr(self.port) + ' ' +\
11589            'port_override: ' + repr(self.port_override) + ' ' +\
11590            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11591            'tags: ' + repr(self.tags) + ' ' +\
11592            'username: ' + repr(self.username) + ' ' +\
11593            '>'
11594
11595    def to_dict(self):
11596        return {
11597            'bind_interface': self.bind_interface,
11598            'database': self.database,
11599            'egress_filter': self.egress_filter,
11600            'healthy': self.healthy,
11601            'hostname': self.hostname,
11602            'id': self.id,
11603            'name': self.name,
11604            'password': self.password,
11605            'port': self.port,
11606            'port_override': self.port_override,
11607            'secret_store_id': self.secret_store_id,
11608            'tags': self.tags,
11609            'username': self.username,
11610        }
11611
11612    @classmethod
11613    def from_dict(cls, d):
11614        return cls(
11615            bind_interface=d.get('bind_interface'),
11616            database=d.get('database'),
11617            egress_filter=d.get('egress_filter'),
11618            healthy=d.get('healthy'),
11619            hostname=d.get('hostname'),
11620            id=d.get('id'),
11621            name=d.get('name'),
11622            password=d.get('password'),
11623            port=d.get('port'),
11624            port_override=d.get('port_override'),
11625            secret_store_id=d.get('secret_store_id'),
11626            tags=d.get('tags'),
11627            username=d.get('username'),
11628        )
11629
11630
11631class Snowflake:
11632    __slots__ = [
11633        'bind_interface',
11634        'database',
11635        'egress_filter',
11636        'healthy',
11637        'hostname',
11638        'id',
11639        'name',
11640        'password',
11641        'port_override',
11642        'schema',
11643        'secret_store_id',
11644        'tags',
11645        'username',
11646    ]
11647
11648    def __init__(
11649        self,
11650        bind_interface=None,
11651        database=None,
11652        egress_filter=None,
11653        healthy=None,
11654        hostname=None,
11655        id=None,
11656        name=None,
11657        password=None,
11658        port_override=None,
11659        schema=None,
11660        secret_store_id=None,
11661        tags=None,
11662        username=None,
11663    ):
11664        self.bind_interface = bind_interface if bind_interface is not None else ''
11665        '''
11666         Bind interface
11667        '''
11668        self.database = database if database is not None else ''
11669        self.egress_filter = egress_filter if egress_filter is not None else ''
11670        '''
11671         A filter applied to the routing logic to pin datasource to nodes.
11672        '''
11673        self.healthy = healthy if healthy is not None else False
11674        '''
11675         True if the datasource is reachable and the credentials are valid.
11676        '''
11677        self.hostname = hostname if hostname is not None else ''
11678        self.id = id if id is not None else ''
11679        '''
11680         Unique identifier of the Resource.
11681        '''
11682        self.name = name if name is not None else ''
11683        '''
11684         Unique human-readable name of the Resource.
11685        '''
11686        self.password = password if password is not None else ''
11687        self.port_override = port_override if port_override is not None else 0
11688        self.schema = schema if schema is not None else ''
11689        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11690        '''
11691         ID of the secret store containing credentials for this resource, if any.
11692        '''
11693        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11694        '''
11695         Tags is a map of key, value pairs.
11696        '''
11697        self.username = username if username is not None else ''
11698
11699    def __repr__(self):
11700        return '<sdm.Snowflake ' + \
11701            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11702            'database: ' + repr(self.database) + ' ' +\
11703            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11704            'healthy: ' + repr(self.healthy) + ' ' +\
11705            'hostname: ' + repr(self.hostname) + ' ' +\
11706            'id: ' + repr(self.id) + ' ' +\
11707            'name: ' + repr(self.name) + ' ' +\
11708            'password: ' + repr(self.password) + ' ' +\
11709            'port_override: ' + repr(self.port_override) + ' ' +\
11710            'schema: ' + repr(self.schema) + ' ' +\
11711            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11712            'tags: ' + repr(self.tags) + ' ' +\
11713            'username: ' + repr(self.username) + ' ' +\
11714            '>'
11715
11716    def to_dict(self):
11717        return {
11718            'bind_interface': self.bind_interface,
11719            'database': self.database,
11720            'egress_filter': self.egress_filter,
11721            'healthy': self.healthy,
11722            'hostname': self.hostname,
11723            'id': self.id,
11724            'name': self.name,
11725            'password': self.password,
11726            'port_override': self.port_override,
11727            'schema': self.schema,
11728            'secret_store_id': self.secret_store_id,
11729            'tags': self.tags,
11730            'username': self.username,
11731        }
11732
11733    @classmethod
11734    def from_dict(cls, d):
11735        return cls(
11736            bind_interface=d.get('bind_interface'),
11737            database=d.get('database'),
11738            egress_filter=d.get('egress_filter'),
11739            healthy=d.get('healthy'),
11740            hostname=d.get('hostname'),
11741            id=d.get('id'),
11742            name=d.get('name'),
11743            password=d.get('password'),
11744            port_override=d.get('port_override'),
11745            schema=d.get('schema'),
11746            secret_store_id=d.get('secret_store_id'),
11747            tags=d.get('tags'),
11748            username=d.get('username'),
11749        )
11750
11751
11752class Snowsight:
11753    '''
11754    Snowsight is currently unstable, and its API may change, or it may be removed,
11755    without a major version bump.
11756    '''
11757    __slots__ = [
11758        'bind_interface',
11759        'egress_filter',
11760        'healthcheck_username',
11761        'healthy',
11762        'id',
11763        'name',
11764        'port_override',
11765        'samlmetadata',
11766        'secret_store_id',
11767        'subdomain',
11768        'tags',
11769    ]
11770
11771    def __init__(
11772        self,
11773        bind_interface=None,
11774        egress_filter=None,
11775        healthcheck_username=None,
11776        healthy=None,
11777        id=None,
11778        name=None,
11779        port_override=None,
11780        samlmetadata=None,
11781        secret_store_id=None,
11782        subdomain=None,
11783        tags=None,
11784    ):
11785        self.bind_interface = bind_interface if bind_interface is not None else ''
11786        '''
11787         Bind interface
11788        '''
11789        self.egress_filter = egress_filter if egress_filter is not None else ''
11790        '''
11791         A filter applied to the routing logic to pin datasource to nodes.
11792        '''
11793        self.healthcheck_username = healthcheck_username if healthcheck_username is not None else ''
11794        self.healthy = healthy if healthy is not None else False
11795        '''
11796         True if the datasource is reachable and the credentials are valid.
11797        '''
11798        self.id = id if id is not None else ''
11799        '''
11800         Unique identifier of the Resource.
11801        '''
11802        self.name = name if name is not None else ''
11803        '''
11804         Unique human-readable name of the Resource.
11805        '''
11806        self.port_override = port_override if port_override is not None else 0
11807        self.samlmetadata = samlmetadata if samlmetadata is not None else ''
11808        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11809        '''
11810         ID of the secret store containing credentials for this resource, if any.
11811        '''
11812        self.subdomain = subdomain if subdomain is not None else ''
11813        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11814        '''
11815         Tags is a map of key, value pairs.
11816        '''
11817
11818    def __repr__(self):
11819        return '<sdm.Snowsight ' + \
11820            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11821            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11822            'healthcheck_username: ' + repr(self.healthcheck_username) + ' ' +\
11823            'healthy: ' + repr(self.healthy) + ' ' +\
11824            'id: ' + repr(self.id) + ' ' +\
11825            'name: ' + repr(self.name) + ' ' +\
11826            'port_override: ' + repr(self.port_override) + ' ' +\
11827            'samlmetadata: ' + repr(self.samlmetadata) + ' ' +\
11828            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11829            'subdomain: ' + repr(self.subdomain) + ' ' +\
11830            'tags: ' + repr(self.tags) + ' ' +\
11831            '>'
11832
11833    def to_dict(self):
11834        return {
11835            'bind_interface': self.bind_interface,
11836            'egress_filter': self.egress_filter,
11837            'healthcheck_username': self.healthcheck_username,
11838            'healthy': self.healthy,
11839            'id': self.id,
11840            'name': self.name,
11841            'port_override': self.port_override,
11842            'samlmetadata': self.samlmetadata,
11843            'secret_store_id': self.secret_store_id,
11844            'subdomain': self.subdomain,
11845            'tags': self.tags,
11846        }
11847
11848    @classmethod
11849    def from_dict(cls, d):
11850        return cls(
11851            bind_interface=d.get('bind_interface'),
11852            egress_filter=d.get('egress_filter'),
11853            healthcheck_username=d.get('healthcheck_username'),
11854            healthy=d.get('healthy'),
11855            id=d.get('id'),
11856            name=d.get('name'),
11857            port_override=d.get('port_override'),
11858            samlmetadata=d.get('samlmetadata'),
11859            secret_store_id=d.get('secret_store_id'),
11860            subdomain=d.get('subdomain'),
11861            tags=d.get('tags'),
11862        )
11863
11864
11865class Sybase:
11866    __slots__ = [
11867        'bind_interface',
11868        'egress_filter',
11869        'healthy',
11870        'hostname',
11871        'id',
11872        'name',
11873        'password',
11874        'port',
11875        'port_override',
11876        'secret_store_id',
11877        'tags',
11878        'username',
11879    ]
11880
11881    def __init__(
11882        self,
11883        bind_interface=None,
11884        egress_filter=None,
11885        healthy=None,
11886        hostname=None,
11887        id=None,
11888        name=None,
11889        password=None,
11890        port=None,
11891        port_override=None,
11892        secret_store_id=None,
11893        tags=None,
11894        username=None,
11895    ):
11896        self.bind_interface = bind_interface if bind_interface is not None else ''
11897        '''
11898         Bind interface
11899        '''
11900        self.egress_filter = egress_filter if egress_filter is not None else ''
11901        '''
11902         A filter applied to the routing logic to pin datasource to nodes.
11903        '''
11904        self.healthy = healthy if healthy is not None else False
11905        '''
11906         True if the datasource is reachable and the credentials are valid.
11907        '''
11908        self.hostname = hostname if hostname is not None else ''
11909        self.id = id if id is not None else ''
11910        '''
11911         Unique identifier of the Resource.
11912        '''
11913        self.name = name if name is not None else ''
11914        '''
11915         Unique human-readable name of the Resource.
11916        '''
11917        self.password = password if password is not None else ''
11918        self.port = port if port is not None else 0
11919        self.port_override = port_override if port_override is not None else 0
11920        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11921        '''
11922         ID of the secret store containing credentials for this resource, if any.
11923        '''
11924        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11925        '''
11926         Tags is a map of key, value pairs.
11927        '''
11928        self.username = username if username is not None else ''
11929
11930    def __repr__(self):
11931        return '<sdm.Sybase ' + \
11932            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11933            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11934            'healthy: ' + repr(self.healthy) + ' ' +\
11935            'hostname: ' + repr(self.hostname) + ' ' +\
11936            'id: ' + repr(self.id) + ' ' +\
11937            'name: ' + repr(self.name) + ' ' +\
11938            'password: ' + repr(self.password) + ' ' +\
11939            'port: ' + repr(self.port) + ' ' +\
11940            'port_override: ' + repr(self.port_override) + ' ' +\
11941            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11942            'tags: ' + repr(self.tags) + ' ' +\
11943            'username: ' + repr(self.username) + ' ' +\
11944            '>'
11945
11946    def to_dict(self):
11947        return {
11948            'bind_interface': self.bind_interface,
11949            'egress_filter': self.egress_filter,
11950            'healthy': self.healthy,
11951            'hostname': self.hostname,
11952            'id': self.id,
11953            'name': self.name,
11954            'password': self.password,
11955            'port': self.port,
11956            'port_override': self.port_override,
11957            'secret_store_id': self.secret_store_id,
11958            'tags': self.tags,
11959            'username': self.username,
11960        }
11961
11962    @classmethod
11963    def from_dict(cls, d):
11964        return cls(
11965            bind_interface=d.get('bind_interface'),
11966            egress_filter=d.get('egress_filter'),
11967            healthy=d.get('healthy'),
11968            hostname=d.get('hostname'),
11969            id=d.get('id'),
11970            name=d.get('name'),
11971            password=d.get('password'),
11972            port=d.get('port'),
11973            port_override=d.get('port_override'),
11974            secret_store_id=d.get('secret_store_id'),
11975            tags=d.get('tags'),
11976            username=d.get('username'),
11977        )
11978
11979
11980class SybaseIQ:
11981    __slots__ = [
11982        'bind_interface',
11983        'egress_filter',
11984        'healthy',
11985        'hostname',
11986        'id',
11987        'name',
11988        'password',
11989        'port',
11990        'port_override',
11991        'secret_store_id',
11992        'tags',
11993        'username',
11994    ]
11995
11996    def __init__(
11997        self,
11998        bind_interface=None,
11999        egress_filter=None,
12000        healthy=None,
12001        hostname=None,
12002        id=None,
12003        name=None,
12004        password=None,
12005        port=None,
12006        port_override=None,
12007        secret_store_id=None,
12008        tags=None,
12009        username=None,
12010    ):
12011        self.bind_interface = bind_interface if bind_interface is not None else ''
12012        '''
12013         Bind interface
12014        '''
12015        self.egress_filter = egress_filter if egress_filter is not None else ''
12016        '''
12017         A filter applied to the routing logic to pin datasource to nodes.
12018        '''
12019        self.healthy = healthy if healthy is not None else False
12020        '''
12021         True if the datasource is reachable and the credentials are valid.
12022        '''
12023        self.hostname = hostname if hostname is not None else ''
12024        self.id = id if id is not None else ''
12025        '''
12026         Unique identifier of the Resource.
12027        '''
12028        self.name = name if name is not None else ''
12029        '''
12030         Unique human-readable name of the Resource.
12031        '''
12032        self.password = password if password is not None else ''
12033        self.port = port if port is not None else 0
12034        self.port_override = port_override if port_override is not None else 0
12035        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12036        '''
12037         ID of the secret store containing credentials for this resource, if any.
12038        '''
12039        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12040        '''
12041         Tags is a map of key, value pairs.
12042        '''
12043        self.username = username if username is not None else ''
12044
12045    def __repr__(self):
12046        return '<sdm.SybaseIQ ' + \
12047            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12048            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12049            'healthy: ' + repr(self.healthy) + ' ' +\
12050            'hostname: ' + repr(self.hostname) + ' ' +\
12051            'id: ' + repr(self.id) + ' ' +\
12052            'name: ' + repr(self.name) + ' ' +\
12053            'password: ' + repr(self.password) + ' ' +\
12054            'port: ' + repr(self.port) + ' ' +\
12055            'port_override: ' + repr(self.port_override) + ' ' +\
12056            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12057            'tags: ' + repr(self.tags) + ' ' +\
12058            'username: ' + repr(self.username) + ' ' +\
12059            '>'
12060
12061    def to_dict(self):
12062        return {
12063            'bind_interface': self.bind_interface,
12064            'egress_filter': self.egress_filter,
12065            'healthy': self.healthy,
12066            'hostname': self.hostname,
12067            'id': self.id,
12068            'name': self.name,
12069            'password': self.password,
12070            'port': self.port,
12071            'port_override': self.port_override,
12072            'secret_store_id': self.secret_store_id,
12073            'tags': self.tags,
12074            'username': self.username,
12075        }
12076
12077    @classmethod
12078    def from_dict(cls, d):
12079        return cls(
12080            bind_interface=d.get('bind_interface'),
12081            egress_filter=d.get('egress_filter'),
12082            healthy=d.get('healthy'),
12083            hostname=d.get('hostname'),
12084            id=d.get('id'),
12085            name=d.get('name'),
12086            password=d.get('password'),
12087            port=d.get('port'),
12088            port_override=d.get('port_override'),
12089            secret_store_id=d.get('secret_store_id'),
12090            tags=d.get('tags'),
12091            username=d.get('username'),
12092        )
12093
12094
12095class Tag:
12096    __slots__ = [
12097        'name',
12098        'value',
12099    ]
12100
12101    def __init__(
12102        self,
12103        name=None,
12104        value=None,
12105    ):
12106        self.name = name if name is not None else ''
12107        self.value = value if value is not None else ''
12108
12109    def __repr__(self):
12110        return '<sdm.Tag ' + \
12111            'name: ' + repr(self.name) + ' ' +\
12112            'value: ' + repr(self.value) + ' ' +\
12113            '>'
12114
12115    def to_dict(self):
12116        return {
12117            'name': self.name,
12118            'value': self.value,
12119        }
12120
12121    @classmethod
12122    def from_dict(cls, d):
12123        return cls(
12124            name=d.get('name'),
12125            value=d.get('value'),
12126        )
12127
12128
12129class Teradata:
12130    __slots__ = [
12131        'bind_interface',
12132        'egress_filter',
12133        'healthy',
12134        'hostname',
12135        'id',
12136        'name',
12137        'password',
12138        'port',
12139        'port_override',
12140        'secret_store_id',
12141        'tags',
12142        'username',
12143    ]
12144
12145    def __init__(
12146        self,
12147        bind_interface=None,
12148        egress_filter=None,
12149        healthy=None,
12150        hostname=None,
12151        id=None,
12152        name=None,
12153        password=None,
12154        port=None,
12155        port_override=None,
12156        secret_store_id=None,
12157        tags=None,
12158        username=None,
12159    ):
12160        self.bind_interface = bind_interface if bind_interface is not None else ''
12161        '''
12162         Bind interface
12163        '''
12164        self.egress_filter = egress_filter if egress_filter is not None else ''
12165        '''
12166         A filter applied to the routing logic to pin datasource to nodes.
12167        '''
12168        self.healthy = healthy if healthy is not None else False
12169        '''
12170         True if the datasource is reachable and the credentials are valid.
12171        '''
12172        self.hostname = hostname if hostname is not None else ''
12173        self.id = id if id is not None else ''
12174        '''
12175         Unique identifier of the Resource.
12176        '''
12177        self.name = name if name is not None else ''
12178        '''
12179         Unique human-readable name of the Resource.
12180        '''
12181        self.password = password if password is not None else ''
12182        self.port = port if port is not None else 0
12183        self.port_override = port_override if port_override is not None else 0
12184        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12185        '''
12186         ID of the secret store containing credentials for this resource, if any.
12187        '''
12188        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12189        '''
12190         Tags is a map of key, value pairs.
12191        '''
12192        self.username = username if username is not None else ''
12193
12194    def __repr__(self):
12195        return '<sdm.Teradata ' + \
12196            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12197            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12198            'healthy: ' + repr(self.healthy) + ' ' +\
12199            'hostname: ' + repr(self.hostname) + ' ' +\
12200            'id: ' + repr(self.id) + ' ' +\
12201            'name: ' + repr(self.name) + ' ' +\
12202            'password: ' + repr(self.password) + ' ' +\
12203            'port: ' + repr(self.port) + ' ' +\
12204            'port_override: ' + repr(self.port_override) + ' ' +\
12205            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12206            'tags: ' + repr(self.tags) + ' ' +\
12207            'username: ' + repr(self.username) + ' ' +\
12208            '>'
12209
12210    def to_dict(self):
12211        return {
12212            'bind_interface': self.bind_interface,
12213            'egress_filter': self.egress_filter,
12214            'healthy': self.healthy,
12215            'hostname': self.hostname,
12216            'id': self.id,
12217            'name': self.name,
12218            'password': self.password,
12219            'port': self.port,
12220            'port_override': self.port_override,
12221            'secret_store_id': self.secret_store_id,
12222            'tags': self.tags,
12223            'username': self.username,
12224        }
12225
12226    @classmethod
12227    def from_dict(cls, d):
12228        return cls(
12229            bind_interface=d.get('bind_interface'),
12230            egress_filter=d.get('egress_filter'),
12231            healthy=d.get('healthy'),
12232            hostname=d.get('hostname'),
12233            id=d.get('id'),
12234            name=d.get('name'),
12235            password=d.get('password'),
12236            port=d.get('port'),
12237            port_override=d.get('port_override'),
12238            secret_store_id=d.get('secret_store_id'),
12239            tags=d.get('tags'),
12240            username=d.get('username'),
12241        )
12242
12243
12244class UpdateResponseMetadata:
12245    '''
12246         UpdateResponseMetadata is reserved for future use.
12247    '''
12248    __slots__ = []
12249
12250    def __init__(self, ):
12251        pass
12252
12253    def __repr__(self):
12254        return '<sdm.UpdateResponseMetadata ' + \
12255            '>'
12256
12257    def to_dict(self):
12258        return {}
12259
12260    @classmethod
12261    def from_dict(cls, d):
12262        return cls()
12263
12264
12265class User:
12266    '''
12267         A User can connect to resources they are granted directly, or granted
12268     via roles.
12269    '''
12270    __slots__ = [
12271        'email',
12272        'external_id',
12273        'first_name',
12274        'id',
12275        'last_name',
12276        'managed_by',
12277        'permission_level',
12278        'suspended',
12279        'tags',
12280    ]
12281
12282    def __init__(
12283        self,
12284        email=None,
12285        external_id=None,
12286        first_name=None,
12287        id=None,
12288        last_name=None,
12289        managed_by=None,
12290        permission_level=None,
12291        suspended=None,
12292        tags=None,
12293    ):
12294        self.email = email if email is not None else ''
12295        '''
12296         The User's email address. Must be unique.
12297        '''
12298        self.external_id = external_id if external_id is not None else ''
12299        '''
12300         External ID is an alternative unique ID this user is represented by within an external service.
12301        '''
12302        self.first_name = first_name if first_name is not None else ''
12303        '''
12304         The User's first name.
12305        '''
12306        self.id = id if id is not None else ''
12307        '''
12308         Unique identifier of the User.
12309        '''
12310        self.last_name = last_name if last_name is not None else ''
12311        '''
12312         The User's last name.
12313        '''
12314        self.managed_by = managed_by if managed_by is not None else ''
12315        '''
12316         Managed By is a read only field for what service manages this user, e.g. StrongDM, Okta, Azure.
12317        '''
12318        self.permission_level = permission_level if permission_level is not None else ''
12319        '''
12320         PermissionLevel is a read only field for the user's permission level e.g. admin, DBA, user.
12321        '''
12322        self.suspended = suspended if suspended is not None else False
12323        '''
12324         The User's suspended state.
12325        '''
12326        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12327        '''
12328         Tags is a map of key, value pairs.
12329        '''
12330
12331    def __repr__(self):
12332        return '<sdm.User ' + \
12333            'email: ' + repr(self.email) + ' ' +\
12334            'external_id: ' + repr(self.external_id) + ' ' +\
12335            'first_name: ' + repr(self.first_name) + ' ' +\
12336            'id: ' + repr(self.id) + ' ' +\
12337            'last_name: ' + repr(self.last_name) + ' ' +\
12338            'managed_by: ' + repr(self.managed_by) + ' ' +\
12339            'permission_level: ' + repr(self.permission_level) + ' ' +\
12340            'suspended: ' + repr(self.suspended) + ' ' +\
12341            'tags: ' + repr(self.tags) + ' ' +\
12342            '>'
12343
12344    def to_dict(self):
12345        return {
12346            'email': self.email,
12347            'external_id': self.external_id,
12348            'first_name': self.first_name,
12349            'id': self.id,
12350            'last_name': self.last_name,
12351            'managed_by': self.managed_by,
12352            'permission_level': self.permission_level,
12353            'suspended': self.suspended,
12354            'tags': self.tags,
12355        }
12356
12357    @classmethod
12358    def from_dict(cls, d):
12359        return cls(
12360            email=d.get('email'),
12361            external_id=d.get('external_id'),
12362            first_name=d.get('first_name'),
12363            id=d.get('id'),
12364            last_name=d.get('last_name'),
12365            managed_by=d.get('managed_by'),
12366            permission_level=d.get('permission_level'),
12367            suspended=d.get('suspended'),
12368            tags=d.get('tags'),
12369        )
12370
12371
12372class VaultAppRoleStore:
12373    __slots__ = [
12374        'id',
12375        'name',
12376        'namespace',
12377        'server_address',
12378        'tags',
12379    ]
12380
12381    def __init__(
12382        self,
12383        id=None,
12384        name=None,
12385        namespace=None,
12386        server_address=None,
12387        tags=None,
12388    ):
12389        self.id = id if id is not None else ''
12390        '''
12391         Unique identifier of the SecretStore.
12392        '''
12393        self.name = name if name is not None else ''
12394        '''
12395         Unique human-readable name of the SecretStore.
12396        '''
12397        self.namespace = namespace if namespace is not None else ''
12398        self.server_address = server_address if server_address is not None else ''
12399        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12400        '''
12401         Tags is a map of key, value pairs.
12402        '''
12403
12404    def __repr__(self):
12405        return '<sdm.VaultAppRoleStore ' + \
12406            'id: ' + repr(self.id) + ' ' +\
12407            'name: ' + repr(self.name) + ' ' +\
12408            'namespace: ' + repr(self.namespace) + ' ' +\
12409            'server_address: ' + repr(self.server_address) + ' ' +\
12410            'tags: ' + repr(self.tags) + ' ' +\
12411            '>'
12412
12413    def to_dict(self):
12414        return {
12415            'id': self.id,
12416            'name': self.name,
12417            'namespace': self.namespace,
12418            'server_address': self.server_address,
12419            'tags': self.tags,
12420        }
12421
12422    @classmethod
12423    def from_dict(cls, d):
12424        return cls(
12425            id=d.get('id'),
12426            name=d.get('name'),
12427            namespace=d.get('namespace'),
12428            server_address=d.get('server_address'),
12429            tags=d.get('tags'),
12430        )
12431
12432
12433class VaultTLSStore:
12434    __slots__ = [
12435        'ca_cert_path',
12436        'client_cert_path',
12437        'client_key_path',
12438        'id',
12439        'name',
12440        'namespace',
12441        'server_address',
12442        'tags',
12443    ]
12444
12445    def __init__(
12446        self,
12447        ca_cert_path=None,
12448        client_cert_path=None,
12449        client_key_path=None,
12450        id=None,
12451        name=None,
12452        namespace=None,
12453        server_address=None,
12454        tags=None,
12455    ):
12456        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
12457        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
12458        self.client_key_path = client_key_path if client_key_path is not None else ''
12459        self.id = id if id is not None else ''
12460        '''
12461         Unique identifier of the SecretStore.
12462        '''
12463        self.name = name if name is not None else ''
12464        '''
12465         Unique human-readable name of the SecretStore.
12466        '''
12467        self.namespace = namespace if namespace is not None else ''
12468        self.server_address = server_address if server_address is not None else ''
12469        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12470        '''
12471         Tags is a map of key, value pairs.
12472        '''
12473
12474    def __repr__(self):
12475        return '<sdm.VaultTLSStore ' + \
12476            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
12477            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
12478            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
12479            'id: ' + repr(self.id) + ' ' +\
12480            'name: ' + repr(self.name) + ' ' +\
12481            'namespace: ' + repr(self.namespace) + ' ' +\
12482            'server_address: ' + repr(self.server_address) + ' ' +\
12483            'tags: ' + repr(self.tags) + ' ' +\
12484            '>'
12485
12486    def to_dict(self):
12487        return {
12488            'ca_cert_path': self.ca_cert_path,
12489            'client_cert_path': self.client_cert_path,
12490            'client_key_path': self.client_key_path,
12491            'id': self.id,
12492            'name': self.name,
12493            'namespace': self.namespace,
12494            'server_address': self.server_address,
12495            'tags': self.tags,
12496        }
12497
12498    @classmethod
12499    def from_dict(cls, d):
12500        return cls(
12501            ca_cert_path=d.get('ca_cert_path'),
12502            client_cert_path=d.get('client_cert_path'),
12503            client_key_path=d.get('client_key_path'),
12504            id=d.get('id'),
12505            name=d.get('name'),
12506            namespace=d.get('namespace'),
12507            server_address=d.get('server_address'),
12508            tags=d.get('tags'),
12509        )
12510
12511
12512class VaultTokenStore:
12513    __slots__ = [
12514        'id',
12515        'name',
12516        'namespace',
12517        'server_address',
12518        'tags',
12519    ]
12520
12521    def __init__(
12522        self,
12523        id=None,
12524        name=None,
12525        namespace=None,
12526        server_address=None,
12527        tags=None,
12528    ):
12529        self.id = id if id is not None else ''
12530        '''
12531         Unique identifier of the SecretStore.
12532        '''
12533        self.name = name if name is not None else ''
12534        '''
12535         Unique human-readable name of the SecretStore.
12536        '''
12537        self.namespace = namespace if namespace is not None else ''
12538        self.server_address = server_address if server_address is not None else ''
12539        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12540        '''
12541         Tags is a map of key, value pairs.
12542        '''
12543
12544    def __repr__(self):
12545        return '<sdm.VaultTokenStore ' + \
12546            'id: ' + repr(self.id) + ' ' +\
12547            'name: ' + repr(self.name) + ' ' +\
12548            'namespace: ' + repr(self.namespace) + ' ' +\
12549            'server_address: ' + repr(self.server_address) + ' ' +\
12550            'tags: ' + repr(self.tags) + ' ' +\
12551            '>'
12552
12553    def to_dict(self):
12554        return {
12555            'id': self.id,
12556            'name': self.name,
12557            'namespace': self.namespace,
12558            'server_address': self.server_address,
12559            'tags': self.tags,
12560        }
12561
12562    @classmethod
12563    def from_dict(cls, d):
12564        return cls(
12565            id=d.get('id'),
12566            name=d.get('name'),
12567            namespace=d.get('namespace'),
12568            server_address=d.get('server_address'),
12569            tags=d.get('tags'),
12570        )
12571
12572
12573def _porcelain_zero_value_tags():
12574    return {}
12575
12576
12577def _porcelain_zero_value_access_rules():
12578    return []
class AKS:
 22class AKS:
 23    __slots__ = [
 24        'bind_interface',
 25        'certificate_authority',
 26        'client_certificate',
 27        'client_key',
 28        'egress_filter',
 29        'healthcheck_namespace',
 30        'healthy',
 31        'hostname',
 32        'id',
 33        'name',
 34        'port',
 35        'port_override',
 36        'remote_identity_group_id',
 37        'remote_identity_healthcheck_username',
 38        'secret_store_id',
 39        'tags',
 40    ]
 41
 42    def __init__(
 43        self,
 44        bind_interface=None,
 45        certificate_authority=None,
 46        client_certificate=None,
 47        client_key=None,
 48        egress_filter=None,
 49        healthcheck_namespace=None,
 50        healthy=None,
 51        hostname=None,
 52        id=None,
 53        name=None,
 54        port=None,
 55        port_override=None,
 56        remote_identity_group_id=None,
 57        remote_identity_healthcheck_username=None,
 58        secret_store_id=None,
 59        tags=None,
 60    ):
 61        self.bind_interface = bind_interface if bind_interface is not None else ''
 62        '''
 63         Bind interface
 64        '''
 65        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 66        self.client_certificate = client_certificate if client_certificate is not None else ''
 67        self.client_key = client_key if client_key is not None else ''
 68        self.egress_filter = egress_filter if egress_filter is not None else ''
 69        '''
 70         A filter applied to the routing logic to pin datasource to nodes.
 71        '''
 72        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 73        '''
 74         The path used to check the health of your connection.  Defaults to `default`.
 75        '''
 76        self.healthy = healthy if healthy is not None else False
 77        '''
 78         True if the datasource is reachable and the credentials are valid.
 79        '''
 80        self.hostname = hostname if hostname is not None else ''
 81        self.id = id if id is not None else ''
 82        '''
 83         Unique identifier of the Resource.
 84        '''
 85        self.name = name if name is not None else ''
 86        '''
 87         Unique human-readable name of the Resource.
 88        '''
 89        self.port = port if port is not None else 0
 90        self.port_override = port_override if port_override is not None else 0
 91        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 92        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 93        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 94        '''
 95         ID of the secret store containing credentials for this resource, if any.
 96        '''
 97        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 98        '''
 99         Tags is a map of key, value pairs.
100        '''
101
102    def __repr__(self):
103        return '<sdm.AKS ' + \
104            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
105            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
106            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
107            'client_key: ' + repr(self.client_key) + ' ' +\
108            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
109            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
110            'healthy: ' + repr(self.healthy) + ' ' +\
111            'hostname: ' + repr(self.hostname) + ' ' +\
112            'id: ' + repr(self.id) + ' ' +\
113            'name: ' + repr(self.name) + ' ' +\
114            'port: ' + repr(self.port) + ' ' +\
115            'port_override: ' + repr(self.port_override) + ' ' +\
116            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
117            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
118            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
119            'tags: ' + repr(self.tags) + ' ' +\
120            '>'
121
122    def to_dict(self):
123        return {
124            'bind_interface': self.bind_interface,
125            'certificate_authority': self.certificate_authority,
126            'client_certificate': self.client_certificate,
127            'client_key': self.client_key,
128            'egress_filter': self.egress_filter,
129            'healthcheck_namespace': self.healthcheck_namespace,
130            'healthy': self.healthy,
131            'hostname': self.hostname,
132            'id': self.id,
133            'name': self.name,
134            'port': self.port,
135            'port_override': self.port_override,
136            'remote_identity_group_id': self.remote_identity_group_id,
137            'remote_identity_healthcheck_username':
138            self.remote_identity_healthcheck_username,
139            'secret_store_id': self.secret_store_id,
140            'tags': self.tags,
141        }
142
143    @classmethod
144    def from_dict(cls, d):
145        return cls(
146            bind_interface=d.get('bind_interface'),
147            certificate_authority=d.get('certificate_authority'),
148            client_certificate=d.get('client_certificate'),
149            client_key=d.get('client_key'),
150            egress_filter=d.get('egress_filter'),
151            healthcheck_namespace=d.get('healthcheck_namespace'),
152            healthy=d.get('healthy'),
153            hostname=d.get('hostname'),
154            id=d.get('id'),
155            name=d.get('name'),
156            port=d.get('port'),
157            port_override=d.get('port_override'),
158            remote_identity_group_id=d.get('remote_identity_group_id'),
159            remote_identity_healthcheck_username=d.get(
160                'remote_identity_healthcheck_username'),
161            secret_store_id=d.get('secret_store_id'),
162            tags=d.get('tags'),
163        )
AKS( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None)
 42    def __init__(
 43        self,
 44        bind_interface=None,
 45        certificate_authority=None,
 46        client_certificate=None,
 47        client_key=None,
 48        egress_filter=None,
 49        healthcheck_namespace=None,
 50        healthy=None,
 51        hostname=None,
 52        id=None,
 53        name=None,
 54        port=None,
 55        port_override=None,
 56        remote_identity_group_id=None,
 57        remote_identity_healthcheck_username=None,
 58        secret_store_id=None,
 59        tags=None,
 60    ):
 61        self.bind_interface = bind_interface if bind_interface is not None else ''
 62        '''
 63         Bind interface
 64        '''
 65        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 66        self.client_certificate = client_certificate if client_certificate is not None else ''
 67        self.client_key = client_key if client_key is not None else ''
 68        self.egress_filter = egress_filter if egress_filter is not None else ''
 69        '''
 70         A filter applied to the routing logic to pin datasource to nodes.
 71        '''
 72        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 73        '''
 74         The path used to check the health of your connection.  Defaults to `default`.
 75        '''
 76        self.healthy = healthy if healthy is not None else False
 77        '''
 78         True if the datasource is reachable and the credentials are valid.
 79        '''
 80        self.hostname = hostname if hostname is not None else ''
 81        self.id = id if id is not None else ''
 82        '''
 83         Unique identifier of the Resource.
 84        '''
 85        self.name = name if name is not None else ''
 86        '''
 87         Unique human-readable name of the Resource.
 88        '''
 89        self.port = port if port is not None else 0
 90        self.port_override = port_override if port_override is not None else 0
 91        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 92        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 93        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 94        '''
 95         ID of the secret store containing credentials for this resource, if any.
 96        '''
 97        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 98        '''
 99         Tags is a map of key, value pairs.
100        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
122    def to_dict(self):
123        return {
124            'bind_interface': self.bind_interface,
125            'certificate_authority': self.certificate_authority,
126            'client_certificate': self.client_certificate,
127            'client_key': self.client_key,
128            'egress_filter': self.egress_filter,
129            'healthcheck_namespace': self.healthcheck_namespace,
130            'healthy': self.healthy,
131            'hostname': self.hostname,
132            'id': self.id,
133            'name': self.name,
134            'port': self.port,
135            'port_override': self.port_override,
136            'remote_identity_group_id': self.remote_identity_group_id,
137            'remote_identity_healthcheck_username':
138            self.remote_identity_healthcheck_username,
139            'secret_store_id': self.secret_store_id,
140            'tags': self.tags,
141        }
@classmethod
def from_dict(cls, d)
143    @classmethod
144    def from_dict(cls, d):
145        return cls(
146            bind_interface=d.get('bind_interface'),
147            certificate_authority=d.get('certificate_authority'),
148            client_certificate=d.get('client_certificate'),
149            client_key=d.get('client_key'),
150            egress_filter=d.get('egress_filter'),
151            healthcheck_namespace=d.get('healthcheck_namespace'),
152            healthy=d.get('healthy'),
153            hostname=d.get('hostname'),
154            id=d.get('id'),
155            name=d.get('name'),
156            port=d.get('port'),
157            port_override=d.get('port_override'),
158            remote_identity_group_id=d.get('remote_identity_group_id'),
159            remote_identity_healthcheck_username=d.get(
160                'remote_identity_healthcheck_username'),
161            secret_store_id=d.get('secret_store_id'),
162            tags=d.get('tags'),
163        )
class AKSBasicAuth:
166class AKSBasicAuth:
167    __slots__ = [
168        'bind_interface',
169        'egress_filter',
170        'healthcheck_namespace',
171        'healthy',
172        'hostname',
173        'id',
174        'name',
175        'password',
176        'port',
177        'port_override',
178        'secret_store_id',
179        'tags',
180        'username',
181    ]
182
183    def __init__(
184        self,
185        bind_interface=None,
186        egress_filter=None,
187        healthcheck_namespace=None,
188        healthy=None,
189        hostname=None,
190        id=None,
191        name=None,
192        password=None,
193        port=None,
194        port_override=None,
195        secret_store_id=None,
196        tags=None,
197        username=None,
198    ):
199        self.bind_interface = bind_interface if bind_interface is not None else ''
200        '''
201         Bind interface
202        '''
203        self.egress_filter = egress_filter if egress_filter is not None else ''
204        '''
205         A filter applied to the routing logic to pin datasource to nodes.
206        '''
207        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
208        '''
209         The path used to check the health of your connection.  Defaults to `default`.
210        '''
211        self.healthy = healthy if healthy is not None else False
212        '''
213         True if the datasource is reachable and the credentials are valid.
214        '''
215        self.hostname = hostname if hostname is not None else ''
216        self.id = id if id is not None else ''
217        '''
218         Unique identifier of the Resource.
219        '''
220        self.name = name if name is not None else ''
221        '''
222         Unique human-readable name of the Resource.
223        '''
224        self.password = password if password is not None else ''
225        self.port = port if port is not None else 0
226        self.port_override = port_override if port_override is not None else 0
227        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
228        '''
229         ID of the secret store containing credentials for this resource, if any.
230        '''
231        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
232        '''
233         Tags is a map of key, value pairs.
234        '''
235        self.username = username if username is not None else ''
236
237    def __repr__(self):
238        return '<sdm.AKSBasicAuth ' + \
239            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
240            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
241            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
242            'healthy: ' + repr(self.healthy) + ' ' +\
243            'hostname: ' + repr(self.hostname) + ' ' +\
244            'id: ' + repr(self.id) + ' ' +\
245            'name: ' + repr(self.name) + ' ' +\
246            'password: ' + repr(self.password) + ' ' +\
247            'port: ' + repr(self.port) + ' ' +\
248            'port_override: ' + repr(self.port_override) + ' ' +\
249            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
250            'tags: ' + repr(self.tags) + ' ' +\
251            'username: ' + repr(self.username) + ' ' +\
252            '>'
253
254    def to_dict(self):
255        return {
256            'bind_interface': self.bind_interface,
257            'egress_filter': self.egress_filter,
258            'healthcheck_namespace': self.healthcheck_namespace,
259            'healthy': self.healthy,
260            'hostname': self.hostname,
261            'id': self.id,
262            'name': self.name,
263            'password': self.password,
264            'port': self.port,
265            'port_override': self.port_override,
266            'secret_store_id': self.secret_store_id,
267            'tags': self.tags,
268            'username': self.username,
269        }
270
271    @classmethod
272    def from_dict(cls, d):
273        return cls(
274            bind_interface=d.get('bind_interface'),
275            egress_filter=d.get('egress_filter'),
276            healthcheck_namespace=d.get('healthcheck_namespace'),
277            healthy=d.get('healthy'),
278            hostname=d.get('hostname'),
279            id=d.get('id'),
280            name=d.get('name'),
281            password=d.get('password'),
282            port=d.get('port'),
283            port_override=d.get('port_override'),
284            secret_store_id=d.get('secret_store_id'),
285            tags=d.get('tags'),
286            username=d.get('username'),
287        )
AKSBasicAuth( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
183    def __init__(
184        self,
185        bind_interface=None,
186        egress_filter=None,
187        healthcheck_namespace=None,
188        healthy=None,
189        hostname=None,
190        id=None,
191        name=None,
192        password=None,
193        port=None,
194        port_override=None,
195        secret_store_id=None,
196        tags=None,
197        username=None,
198    ):
199        self.bind_interface = bind_interface if bind_interface is not None else ''
200        '''
201         Bind interface
202        '''
203        self.egress_filter = egress_filter if egress_filter is not None else ''
204        '''
205         A filter applied to the routing logic to pin datasource to nodes.
206        '''
207        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
208        '''
209         The path used to check the health of your connection.  Defaults to `default`.
210        '''
211        self.healthy = healthy if healthy is not None else False
212        '''
213         True if the datasource is reachable and the credentials are valid.
214        '''
215        self.hostname = hostname if hostname is not None else ''
216        self.id = id if id is not None else ''
217        '''
218         Unique identifier of the Resource.
219        '''
220        self.name = name if name is not None else ''
221        '''
222         Unique human-readable name of the Resource.
223        '''
224        self.password = password if password is not None else ''
225        self.port = port if port is not None else 0
226        self.port_override = port_override if port_override is not None else 0
227        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
228        '''
229         ID of the secret store containing credentials for this resource, if any.
230        '''
231        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
232        '''
233         Tags is a map of key, value pairs.
234        '''
235        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
254    def to_dict(self):
255        return {
256            'bind_interface': self.bind_interface,
257            'egress_filter': self.egress_filter,
258            'healthcheck_namespace': self.healthcheck_namespace,
259            'healthy': self.healthy,
260            'hostname': self.hostname,
261            'id': self.id,
262            'name': self.name,
263            'password': self.password,
264            'port': self.port,
265            'port_override': self.port_override,
266            'secret_store_id': self.secret_store_id,
267            'tags': self.tags,
268            'username': self.username,
269        }
@classmethod
def from_dict(cls, d)
271    @classmethod
272    def from_dict(cls, d):
273        return cls(
274            bind_interface=d.get('bind_interface'),
275            egress_filter=d.get('egress_filter'),
276            healthcheck_namespace=d.get('healthcheck_namespace'),
277            healthy=d.get('healthy'),
278            hostname=d.get('hostname'),
279            id=d.get('id'),
280            name=d.get('name'),
281            password=d.get('password'),
282            port=d.get('port'),
283            port_override=d.get('port_override'),
284            secret_store_id=d.get('secret_store_id'),
285            tags=d.get('tags'),
286            username=d.get('username'),
287        )
class AKSServiceAccount:
290class AKSServiceAccount:
291    __slots__ = [
292        'bind_interface',
293        'egress_filter',
294        'healthcheck_namespace',
295        'healthy',
296        'hostname',
297        'id',
298        'name',
299        'port',
300        'port_override',
301        'remote_identity_group_id',
302        'remote_identity_healthcheck_username',
303        'secret_store_id',
304        'tags',
305        'token',
306    ]
307
308    def __init__(
309        self,
310        bind_interface=None,
311        egress_filter=None,
312        healthcheck_namespace=None,
313        healthy=None,
314        hostname=None,
315        id=None,
316        name=None,
317        port=None,
318        port_override=None,
319        remote_identity_group_id=None,
320        remote_identity_healthcheck_username=None,
321        secret_store_id=None,
322        tags=None,
323        token=None,
324    ):
325        self.bind_interface = bind_interface if bind_interface is not None else ''
326        '''
327         Bind interface
328        '''
329        self.egress_filter = egress_filter if egress_filter is not None else ''
330        '''
331         A filter applied to the routing logic to pin datasource to nodes.
332        '''
333        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
334        '''
335         The path used to check the health of your connection.  Defaults to `default`.
336        '''
337        self.healthy = healthy if healthy is not None else False
338        '''
339         True if the datasource is reachable and the credentials are valid.
340        '''
341        self.hostname = hostname if hostname is not None else ''
342        self.id = id if id is not None else ''
343        '''
344         Unique identifier of the Resource.
345        '''
346        self.name = name if name is not None else ''
347        '''
348         Unique human-readable name of the Resource.
349        '''
350        self.port = port if port is not None else 0
351        self.port_override = port_override if port_override is not None else 0
352        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
353        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
354        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
355        '''
356         ID of the secret store containing credentials for this resource, if any.
357        '''
358        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
359        '''
360         Tags is a map of key, value pairs.
361        '''
362        self.token = token if token is not None else ''
363
364    def __repr__(self):
365        return '<sdm.AKSServiceAccount ' + \
366            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
367            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
368            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
369            'healthy: ' + repr(self.healthy) + ' ' +\
370            'hostname: ' + repr(self.hostname) + ' ' +\
371            'id: ' + repr(self.id) + ' ' +\
372            'name: ' + repr(self.name) + ' ' +\
373            'port: ' + repr(self.port) + ' ' +\
374            'port_override: ' + repr(self.port_override) + ' ' +\
375            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
376            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
377            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
378            'tags: ' + repr(self.tags) + ' ' +\
379            'token: ' + repr(self.token) + ' ' +\
380            '>'
381
382    def to_dict(self):
383        return {
384            'bind_interface': self.bind_interface,
385            'egress_filter': self.egress_filter,
386            'healthcheck_namespace': self.healthcheck_namespace,
387            'healthy': self.healthy,
388            'hostname': self.hostname,
389            'id': self.id,
390            'name': self.name,
391            'port': self.port,
392            'port_override': self.port_override,
393            'remote_identity_group_id': self.remote_identity_group_id,
394            'remote_identity_healthcheck_username':
395            self.remote_identity_healthcheck_username,
396            'secret_store_id': self.secret_store_id,
397            'tags': self.tags,
398            'token': self.token,
399        }
400
401    @classmethod
402    def from_dict(cls, d):
403        return cls(
404            bind_interface=d.get('bind_interface'),
405            egress_filter=d.get('egress_filter'),
406            healthcheck_namespace=d.get('healthcheck_namespace'),
407            healthy=d.get('healthy'),
408            hostname=d.get('hostname'),
409            id=d.get('id'),
410            name=d.get('name'),
411            port=d.get('port'),
412            port_override=d.get('port_override'),
413            remote_identity_group_id=d.get('remote_identity_group_id'),
414            remote_identity_healthcheck_username=d.get(
415                'remote_identity_healthcheck_username'),
416            secret_store_id=d.get('secret_store_id'),
417            tags=d.get('tags'),
418            token=d.get('token'),
419        )
AKSServiceAccount( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, token=None)
308    def __init__(
309        self,
310        bind_interface=None,
311        egress_filter=None,
312        healthcheck_namespace=None,
313        healthy=None,
314        hostname=None,
315        id=None,
316        name=None,
317        port=None,
318        port_override=None,
319        remote_identity_group_id=None,
320        remote_identity_healthcheck_username=None,
321        secret_store_id=None,
322        tags=None,
323        token=None,
324    ):
325        self.bind_interface = bind_interface if bind_interface is not None else ''
326        '''
327         Bind interface
328        '''
329        self.egress_filter = egress_filter if egress_filter is not None else ''
330        '''
331         A filter applied to the routing logic to pin datasource to nodes.
332        '''
333        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
334        '''
335         The path used to check the health of your connection.  Defaults to `default`.
336        '''
337        self.healthy = healthy if healthy is not None else False
338        '''
339         True if the datasource is reachable and the credentials are valid.
340        '''
341        self.hostname = hostname if hostname is not None else ''
342        self.id = id if id is not None else ''
343        '''
344         Unique identifier of the Resource.
345        '''
346        self.name = name if name is not None else ''
347        '''
348         Unique human-readable name of the Resource.
349        '''
350        self.port = port if port is not None else 0
351        self.port_override = port_override if port_override is not None else 0
352        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
353        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
354        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
355        '''
356         ID of the secret store containing credentials for this resource, if any.
357        '''
358        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
359        '''
360         Tags is a map of key, value pairs.
361        '''
362        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
382    def to_dict(self):
383        return {
384            'bind_interface': self.bind_interface,
385            'egress_filter': self.egress_filter,
386            'healthcheck_namespace': self.healthcheck_namespace,
387            'healthy': self.healthy,
388            'hostname': self.hostname,
389            'id': self.id,
390            'name': self.name,
391            'port': self.port,
392            'port_override': self.port_override,
393            'remote_identity_group_id': self.remote_identity_group_id,
394            'remote_identity_healthcheck_username':
395            self.remote_identity_healthcheck_username,
396            'secret_store_id': self.secret_store_id,
397            'tags': self.tags,
398            'token': self.token,
399        }
@classmethod
def from_dict(cls, d)
401    @classmethod
402    def from_dict(cls, d):
403        return cls(
404            bind_interface=d.get('bind_interface'),
405            egress_filter=d.get('egress_filter'),
406            healthcheck_namespace=d.get('healthcheck_namespace'),
407            healthy=d.get('healthy'),
408            hostname=d.get('hostname'),
409            id=d.get('id'),
410            name=d.get('name'),
411            port=d.get('port'),
412            port_override=d.get('port_override'),
413            remote_identity_group_id=d.get('remote_identity_group_id'),
414            remote_identity_healthcheck_username=d.get(
415                'remote_identity_healthcheck_username'),
416            secret_store_id=d.get('secret_store_id'),
417            tags=d.get('tags'),
418            token=d.get('token'),
419        )
class AKSServiceAccountUserImpersonation:
422class AKSServiceAccountUserImpersonation:
423    __slots__ = [
424        'bind_interface',
425        'egress_filter',
426        'healthcheck_namespace',
427        'healthy',
428        'hostname',
429        'id',
430        'name',
431        'port',
432        'port_override',
433        'secret_store_id',
434        'tags',
435        'token',
436    ]
437
438    def __init__(
439        self,
440        bind_interface=None,
441        egress_filter=None,
442        healthcheck_namespace=None,
443        healthy=None,
444        hostname=None,
445        id=None,
446        name=None,
447        port=None,
448        port_override=None,
449        secret_store_id=None,
450        tags=None,
451        token=None,
452    ):
453        self.bind_interface = bind_interface if bind_interface is not None else ''
454        '''
455         Bind interface
456        '''
457        self.egress_filter = egress_filter if egress_filter is not None else ''
458        '''
459         A filter applied to the routing logic to pin datasource to nodes.
460        '''
461        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
462        '''
463         The path used to check the health of your connection.  Defaults to `default`.
464        '''
465        self.healthy = healthy if healthy is not None else False
466        '''
467         True if the datasource is reachable and the credentials are valid.
468        '''
469        self.hostname = hostname if hostname is not None else ''
470        self.id = id if id is not None else ''
471        '''
472         Unique identifier of the Resource.
473        '''
474        self.name = name if name is not None else ''
475        '''
476         Unique human-readable name of the Resource.
477        '''
478        self.port = port if port is not None else 0
479        self.port_override = port_override if port_override is not None else 0
480        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
481        '''
482         ID of the secret store containing credentials for this resource, if any.
483        '''
484        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
485        '''
486         Tags is a map of key, value pairs.
487        '''
488        self.token = token if token is not None else ''
489
490    def __repr__(self):
491        return '<sdm.AKSServiceAccountUserImpersonation ' + \
492            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
493            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
494            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
495            'healthy: ' + repr(self.healthy) + ' ' +\
496            'hostname: ' + repr(self.hostname) + ' ' +\
497            'id: ' + repr(self.id) + ' ' +\
498            'name: ' + repr(self.name) + ' ' +\
499            'port: ' + repr(self.port) + ' ' +\
500            'port_override: ' + repr(self.port_override) + ' ' +\
501            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
502            'tags: ' + repr(self.tags) + ' ' +\
503            'token: ' + repr(self.token) + ' ' +\
504            '>'
505
506    def to_dict(self):
507        return {
508            'bind_interface': self.bind_interface,
509            'egress_filter': self.egress_filter,
510            'healthcheck_namespace': self.healthcheck_namespace,
511            'healthy': self.healthy,
512            'hostname': self.hostname,
513            'id': self.id,
514            'name': self.name,
515            'port': self.port,
516            'port_override': self.port_override,
517            'secret_store_id': self.secret_store_id,
518            'tags': self.tags,
519            'token': self.token,
520        }
521
522    @classmethod
523    def from_dict(cls, d):
524        return cls(
525            bind_interface=d.get('bind_interface'),
526            egress_filter=d.get('egress_filter'),
527            healthcheck_namespace=d.get('healthcheck_namespace'),
528            healthy=d.get('healthy'),
529            hostname=d.get('hostname'),
530            id=d.get('id'),
531            name=d.get('name'),
532            port=d.get('port'),
533            port_override=d.get('port_override'),
534            secret_store_id=d.get('secret_store_id'),
535            tags=d.get('tags'),
536            token=d.get('token'),
537        )
AKSServiceAccountUserImpersonation( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None, token=None)
438    def __init__(
439        self,
440        bind_interface=None,
441        egress_filter=None,
442        healthcheck_namespace=None,
443        healthy=None,
444        hostname=None,
445        id=None,
446        name=None,
447        port=None,
448        port_override=None,
449        secret_store_id=None,
450        tags=None,
451        token=None,
452    ):
453        self.bind_interface = bind_interface if bind_interface is not None else ''
454        '''
455         Bind interface
456        '''
457        self.egress_filter = egress_filter if egress_filter is not None else ''
458        '''
459         A filter applied to the routing logic to pin datasource to nodes.
460        '''
461        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
462        '''
463         The path used to check the health of your connection.  Defaults to `default`.
464        '''
465        self.healthy = healthy if healthy is not None else False
466        '''
467         True if the datasource is reachable and the credentials are valid.
468        '''
469        self.hostname = hostname if hostname is not None else ''
470        self.id = id if id is not None else ''
471        '''
472         Unique identifier of the Resource.
473        '''
474        self.name = name if name is not None else ''
475        '''
476         Unique human-readable name of the Resource.
477        '''
478        self.port = port if port is not None else 0
479        self.port_override = port_override if port_override is not None else 0
480        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
481        '''
482         ID of the secret store containing credentials for this resource, if any.
483        '''
484        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
485        '''
486         Tags is a map of key, value pairs.
487        '''
488        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
506    def to_dict(self):
507        return {
508            'bind_interface': self.bind_interface,
509            'egress_filter': self.egress_filter,
510            'healthcheck_namespace': self.healthcheck_namespace,
511            'healthy': self.healthy,
512            'hostname': self.hostname,
513            'id': self.id,
514            'name': self.name,
515            'port': self.port,
516            'port_override': self.port_override,
517            'secret_store_id': self.secret_store_id,
518            'tags': self.tags,
519            'token': self.token,
520        }
@classmethod
def from_dict(cls, d)
522    @classmethod
523    def from_dict(cls, d):
524        return cls(
525            bind_interface=d.get('bind_interface'),
526            egress_filter=d.get('egress_filter'),
527            healthcheck_namespace=d.get('healthcheck_namespace'),
528            healthy=d.get('healthy'),
529            hostname=d.get('hostname'),
530            id=d.get('id'),
531            name=d.get('name'),
532            port=d.get('port'),
533            port_override=d.get('port_override'),
534            secret_store_id=d.get('secret_store_id'),
535            tags=d.get('tags'),
536            token=d.get('token'),
537        )
class AKSUserImpersonation:
540class AKSUserImpersonation:
541    __slots__ = [
542        'bind_interface',
543        'certificate_authority',
544        'client_certificate',
545        'client_key',
546        'egress_filter',
547        'healthcheck_namespace',
548        'healthy',
549        'hostname',
550        'id',
551        'name',
552        'port',
553        'port_override',
554        'secret_store_id',
555        'tags',
556    ]
557
558    def __init__(
559        self,
560        bind_interface=None,
561        certificate_authority=None,
562        client_certificate=None,
563        client_key=None,
564        egress_filter=None,
565        healthcheck_namespace=None,
566        healthy=None,
567        hostname=None,
568        id=None,
569        name=None,
570        port=None,
571        port_override=None,
572        secret_store_id=None,
573        tags=None,
574    ):
575        self.bind_interface = bind_interface if bind_interface is not None else ''
576        '''
577         Bind interface
578        '''
579        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
580        self.client_certificate = client_certificate if client_certificate is not None else ''
581        self.client_key = client_key if client_key is not None else ''
582        self.egress_filter = egress_filter if egress_filter is not None else ''
583        '''
584         A filter applied to the routing logic to pin datasource to nodes.
585        '''
586        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
587        '''
588         The path used to check the health of your connection.  Defaults to `default`.
589        '''
590        self.healthy = healthy if healthy is not None else False
591        '''
592         True if the datasource is reachable and the credentials are valid.
593        '''
594        self.hostname = hostname if hostname is not None else ''
595        self.id = id if id is not None else ''
596        '''
597         Unique identifier of the Resource.
598        '''
599        self.name = name if name is not None else ''
600        '''
601         Unique human-readable name of the Resource.
602        '''
603        self.port = port if port is not None else 0
604        self.port_override = port_override if port_override is not None else 0
605        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
606        '''
607         ID of the secret store containing credentials for this resource, if any.
608        '''
609        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
610        '''
611         Tags is a map of key, value pairs.
612        '''
613
614    def __repr__(self):
615        return '<sdm.AKSUserImpersonation ' + \
616            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
617            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
618            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
619            'client_key: ' + repr(self.client_key) + ' ' +\
620            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
621            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
622            'healthy: ' + repr(self.healthy) + ' ' +\
623            'hostname: ' + repr(self.hostname) + ' ' +\
624            'id: ' + repr(self.id) + ' ' +\
625            'name: ' + repr(self.name) + ' ' +\
626            'port: ' + repr(self.port) + ' ' +\
627            'port_override: ' + repr(self.port_override) + ' ' +\
628            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
629            'tags: ' + repr(self.tags) + ' ' +\
630            '>'
631
632    def to_dict(self):
633        return {
634            'bind_interface': self.bind_interface,
635            'certificate_authority': self.certificate_authority,
636            'client_certificate': self.client_certificate,
637            'client_key': self.client_key,
638            'egress_filter': self.egress_filter,
639            'healthcheck_namespace': self.healthcheck_namespace,
640            'healthy': self.healthy,
641            'hostname': self.hostname,
642            'id': self.id,
643            'name': self.name,
644            'port': self.port,
645            'port_override': self.port_override,
646            'secret_store_id': self.secret_store_id,
647            'tags': self.tags,
648        }
649
650    @classmethod
651    def from_dict(cls, d):
652        return cls(
653            bind_interface=d.get('bind_interface'),
654            certificate_authority=d.get('certificate_authority'),
655            client_certificate=d.get('client_certificate'),
656            client_key=d.get('client_key'),
657            egress_filter=d.get('egress_filter'),
658            healthcheck_namespace=d.get('healthcheck_namespace'),
659            healthy=d.get('healthy'),
660            hostname=d.get('hostname'),
661            id=d.get('id'),
662            name=d.get('name'),
663            port=d.get('port'),
664            port_override=d.get('port_override'),
665            secret_store_id=d.get('secret_store_id'),
666            tags=d.get('tags'),
667        )
AKSUserImpersonation( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
558    def __init__(
559        self,
560        bind_interface=None,
561        certificate_authority=None,
562        client_certificate=None,
563        client_key=None,
564        egress_filter=None,
565        healthcheck_namespace=None,
566        healthy=None,
567        hostname=None,
568        id=None,
569        name=None,
570        port=None,
571        port_override=None,
572        secret_store_id=None,
573        tags=None,
574    ):
575        self.bind_interface = bind_interface if bind_interface is not None else ''
576        '''
577         Bind interface
578        '''
579        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
580        self.client_certificate = client_certificate if client_certificate is not None else ''
581        self.client_key = client_key if client_key is not None else ''
582        self.egress_filter = egress_filter if egress_filter is not None else ''
583        '''
584         A filter applied to the routing logic to pin datasource to nodes.
585        '''
586        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
587        '''
588         The path used to check the health of your connection.  Defaults to `default`.
589        '''
590        self.healthy = healthy if healthy is not None else False
591        '''
592         True if the datasource is reachable and the credentials are valid.
593        '''
594        self.hostname = hostname if hostname is not None else ''
595        self.id = id if id is not None else ''
596        '''
597         Unique identifier of the Resource.
598        '''
599        self.name = name if name is not None else ''
600        '''
601         Unique human-readable name of the Resource.
602        '''
603        self.port = port if port is not None else 0
604        self.port_override = port_override if port_override is not None else 0
605        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
606        '''
607         ID of the secret store containing credentials for this resource, if any.
608        '''
609        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
610        '''
611         Tags is a map of key, value pairs.
612        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
632    def to_dict(self):
633        return {
634            'bind_interface': self.bind_interface,
635            'certificate_authority': self.certificate_authority,
636            'client_certificate': self.client_certificate,
637            'client_key': self.client_key,
638            'egress_filter': self.egress_filter,
639            'healthcheck_namespace': self.healthcheck_namespace,
640            'healthy': self.healthy,
641            'hostname': self.hostname,
642            'id': self.id,
643            'name': self.name,
644            'port': self.port,
645            'port_override': self.port_override,
646            'secret_store_id': self.secret_store_id,
647            'tags': self.tags,
648        }
@classmethod
def from_dict(cls, d)
650    @classmethod
651    def from_dict(cls, d):
652        return cls(
653            bind_interface=d.get('bind_interface'),
654            certificate_authority=d.get('certificate_authority'),
655            client_certificate=d.get('client_certificate'),
656            client_key=d.get('client_key'),
657            egress_filter=d.get('egress_filter'),
658            healthcheck_namespace=d.get('healthcheck_namespace'),
659            healthy=d.get('healthy'),
660            hostname=d.get('hostname'),
661            id=d.get('id'),
662            name=d.get('name'),
663            port=d.get('port'),
664            port_override=d.get('port_override'),
665            secret_store_id=d.get('secret_store_id'),
666            tags=d.get('tags'),
667        )
class AWS:
670class AWS:
671    __slots__ = [
672        'access_key',
673        'bind_interface',
674        'egress_filter',
675        'healthcheck_region',
676        'healthy',
677        'id',
678        'name',
679        'role_arn',
680        'role_external_id',
681        'secret_access_key',
682        'secret_store_id',
683        'tags',
684    ]
685
686    def __init__(
687        self,
688        access_key=None,
689        bind_interface=None,
690        egress_filter=None,
691        healthcheck_region=None,
692        healthy=None,
693        id=None,
694        name=None,
695        role_arn=None,
696        role_external_id=None,
697        secret_access_key=None,
698        secret_store_id=None,
699        tags=None,
700    ):
701        self.access_key = access_key if access_key is not None else ''
702        self.bind_interface = bind_interface if bind_interface is not None else ''
703        '''
704         Bind interface
705        '''
706        self.egress_filter = egress_filter if egress_filter is not None else ''
707        '''
708         A filter applied to the routing logic to pin datasource to nodes.
709        '''
710        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
711        self.healthy = healthy if healthy is not None else False
712        '''
713         True if the datasource is reachable and the credentials are valid.
714        '''
715        self.id = id if id is not None else ''
716        '''
717         Unique identifier of the Resource.
718        '''
719        self.name = name if name is not None else ''
720        '''
721         Unique human-readable name of the Resource.
722        '''
723        self.role_arn = role_arn if role_arn is not None else ''
724        self.role_external_id = role_external_id if role_external_id is not None else ''
725        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
726        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
727        '''
728         ID of the secret store containing credentials for this resource, if any.
729        '''
730        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
731        '''
732         Tags is a map of key, value pairs.
733        '''
734
735    def __repr__(self):
736        return '<sdm.AWS ' + \
737            'access_key: ' + repr(self.access_key) + ' ' +\
738            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
739            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
740            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
741            'healthy: ' + repr(self.healthy) + ' ' +\
742            'id: ' + repr(self.id) + ' ' +\
743            'name: ' + repr(self.name) + ' ' +\
744            'role_arn: ' + repr(self.role_arn) + ' ' +\
745            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
746            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
747            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
748            'tags: ' + repr(self.tags) + ' ' +\
749            '>'
750
751    def to_dict(self):
752        return {
753            'access_key': self.access_key,
754            'bind_interface': self.bind_interface,
755            'egress_filter': self.egress_filter,
756            'healthcheck_region': self.healthcheck_region,
757            'healthy': self.healthy,
758            'id': self.id,
759            'name': self.name,
760            'role_arn': self.role_arn,
761            'role_external_id': self.role_external_id,
762            'secret_access_key': self.secret_access_key,
763            'secret_store_id': self.secret_store_id,
764            'tags': self.tags,
765        }
766
767    @classmethod
768    def from_dict(cls, d):
769        return cls(
770            access_key=d.get('access_key'),
771            bind_interface=d.get('bind_interface'),
772            egress_filter=d.get('egress_filter'),
773            healthcheck_region=d.get('healthcheck_region'),
774            healthy=d.get('healthy'),
775            id=d.get('id'),
776            name=d.get('name'),
777            role_arn=d.get('role_arn'),
778            role_external_id=d.get('role_external_id'),
779            secret_access_key=d.get('secret_access_key'),
780            secret_store_id=d.get('secret_store_id'),
781            tags=d.get('tags'),
782        )
AWS( access_key=None, bind_interface=None, egress_filter=None, healthcheck_region=None, healthy=None, id=None, name=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
686    def __init__(
687        self,
688        access_key=None,
689        bind_interface=None,
690        egress_filter=None,
691        healthcheck_region=None,
692        healthy=None,
693        id=None,
694        name=None,
695        role_arn=None,
696        role_external_id=None,
697        secret_access_key=None,
698        secret_store_id=None,
699        tags=None,
700    ):
701        self.access_key = access_key if access_key is not None else ''
702        self.bind_interface = bind_interface if bind_interface is not None else ''
703        '''
704         Bind interface
705        '''
706        self.egress_filter = egress_filter if egress_filter is not None else ''
707        '''
708         A filter applied to the routing logic to pin datasource to nodes.
709        '''
710        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
711        self.healthy = healthy if healthy is not None else False
712        '''
713         True if the datasource is reachable and the credentials are valid.
714        '''
715        self.id = id if id is not None else ''
716        '''
717         Unique identifier of the Resource.
718        '''
719        self.name = name if name is not None else ''
720        '''
721         Unique human-readable name of the Resource.
722        '''
723        self.role_arn = role_arn if role_arn is not None else ''
724        self.role_external_id = role_external_id if role_external_id is not None else ''
725        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
726        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
727        '''
728         ID of the secret store containing credentials for this resource, if any.
729        '''
730        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
731        '''
732         Tags is a map of key, value pairs.
733        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_region
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
751    def to_dict(self):
752        return {
753            'access_key': self.access_key,
754            'bind_interface': self.bind_interface,
755            'egress_filter': self.egress_filter,
756            'healthcheck_region': self.healthcheck_region,
757            'healthy': self.healthy,
758            'id': self.id,
759            'name': self.name,
760            'role_arn': self.role_arn,
761            'role_external_id': self.role_external_id,
762            'secret_access_key': self.secret_access_key,
763            'secret_store_id': self.secret_store_id,
764            'tags': self.tags,
765        }
@classmethod
def from_dict(cls, d)
767    @classmethod
768    def from_dict(cls, d):
769        return cls(
770            access_key=d.get('access_key'),
771            bind_interface=d.get('bind_interface'),
772            egress_filter=d.get('egress_filter'),
773            healthcheck_region=d.get('healthcheck_region'),
774            healthy=d.get('healthy'),
775            id=d.get('id'),
776            name=d.get('name'),
777            role_arn=d.get('role_arn'),
778            role_external_id=d.get('role_external_id'),
779            secret_access_key=d.get('secret_access_key'),
780            secret_store_id=d.get('secret_store_id'),
781            tags=d.get('tags'),
782        )
class AWSConsole:
785class AWSConsole:
786    '''
787    AWSConsole is currently unstable, and its API may change, or it may be removed,
788    without a major version bump.
789    '''
790    __slots__ = [
791        'bind_interface',
792        'egress_filter',
793        'enable_env_variables',
794        'healthy',
795        'id',
796        'name',
797        'port_override',
798        'region',
799        'remote_identity_group_id',
800        'remote_identity_healthcheck_username',
801        'role_arn',
802        'role_external_id',
803        'secret_store_id',
804        'session_expiry',
805        'subdomain',
806        'tags',
807    ]
808
809    def __init__(
810        self,
811        bind_interface=None,
812        egress_filter=None,
813        enable_env_variables=None,
814        healthy=None,
815        id=None,
816        name=None,
817        port_override=None,
818        region=None,
819        remote_identity_group_id=None,
820        remote_identity_healthcheck_username=None,
821        role_arn=None,
822        role_external_id=None,
823        secret_store_id=None,
824        session_expiry=None,
825        subdomain=None,
826        tags=None,
827    ):
828        self.bind_interface = bind_interface if bind_interface is not None else ''
829        '''
830         Bind interface
831        '''
832        self.egress_filter = egress_filter if egress_filter is not None else ''
833        '''
834         A filter applied to the routing logic to pin datasource to nodes.
835        '''
836        self.enable_env_variables = enable_env_variables if enable_env_variables is not None else False
837        self.healthy = healthy if healthy is not None else False
838        '''
839         True if the datasource is reachable and the credentials are valid.
840        '''
841        self.id = id if id is not None else ''
842        '''
843         Unique identifier of the Resource.
844        '''
845        self.name = name if name is not None else ''
846        '''
847         Unique human-readable name of the Resource.
848        '''
849        self.port_override = port_override if port_override is not None else 0
850        self.region = region if region is not None else ''
851        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
852        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
853        self.role_arn = role_arn if role_arn is not None else ''
854        self.role_external_id = role_external_id if role_external_id is not None else ''
855        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
856        '''
857         ID of the secret store containing credentials for this resource, if any.
858        '''
859        self.session_expiry = session_expiry if session_expiry is not None else 0
860        self.subdomain = subdomain if subdomain is not None else ''
861        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
862        '''
863         Tags is a map of key, value pairs.
864        '''
865
866    def __repr__(self):
867        return '<sdm.AWSConsole ' + \
868            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
869            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
870            'enable_env_variables: ' + repr(self.enable_env_variables) + ' ' +\
871            'healthy: ' + repr(self.healthy) + ' ' +\
872            'id: ' + repr(self.id) + ' ' +\
873            'name: ' + repr(self.name) + ' ' +\
874            'port_override: ' + repr(self.port_override) + ' ' +\
875            'region: ' + repr(self.region) + ' ' +\
876            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
877            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
878            'role_arn: ' + repr(self.role_arn) + ' ' +\
879            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
880            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
881            'session_expiry: ' + repr(self.session_expiry) + ' ' +\
882            'subdomain: ' + repr(self.subdomain) + ' ' +\
883            'tags: ' + repr(self.tags) + ' ' +\
884            '>'
885
886    def to_dict(self):
887        return {
888            'bind_interface': self.bind_interface,
889            'egress_filter': self.egress_filter,
890            'enable_env_variables': self.enable_env_variables,
891            'healthy': self.healthy,
892            'id': self.id,
893            'name': self.name,
894            'port_override': self.port_override,
895            'region': self.region,
896            'remote_identity_group_id': self.remote_identity_group_id,
897            'remote_identity_healthcheck_username':
898            self.remote_identity_healthcheck_username,
899            'role_arn': self.role_arn,
900            'role_external_id': self.role_external_id,
901            'secret_store_id': self.secret_store_id,
902            'session_expiry': self.session_expiry,
903            'subdomain': self.subdomain,
904            'tags': self.tags,
905        }
906
907    @classmethod
908    def from_dict(cls, d):
909        return cls(
910            bind_interface=d.get('bind_interface'),
911            egress_filter=d.get('egress_filter'),
912            enable_env_variables=d.get('enable_env_variables'),
913            healthy=d.get('healthy'),
914            id=d.get('id'),
915            name=d.get('name'),
916            port_override=d.get('port_override'),
917            region=d.get('region'),
918            remote_identity_group_id=d.get('remote_identity_group_id'),
919            remote_identity_healthcheck_username=d.get(
920                'remote_identity_healthcheck_username'),
921            role_arn=d.get('role_arn'),
922            role_external_id=d.get('role_external_id'),
923            secret_store_id=d.get('secret_store_id'),
924            session_expiry=d.get('session_expiry'),
925            subdomain=d.get('subdomain'),
926            tags=d.get('tags'),
927        )

AWSConsole is currently unstable, and its API may change, or it may be removed, without a major version bump.

AWSConsole( bind_interface=None, egress_filter=None, enable_env_variables=None, healthy=None, id=None, name=None, port_override=None, region=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, role_arn=None, role_external_id=None, secret_store_id=None, session_expiry=None, subdomain=None, tags=None)
809    def __init__(
810        self,
811        bind_interface=None,
812        egress_filter=None,
813        enable_env_variables=None,
814        healthy=None,
815        id=None,
816        name=None,
817        port_override=None,
818        region=None,
819        remote_identity_group_id=None,
820        remote_identity_healthcheck_username=None,
821        role_arn=None,
822        role_external_id=None,
823        secret_store_id=None,
824        session_expiry=None,
825        subdomain=None,
826        tags=None,
827    ):
828        self.bind_interface = bind_interface if bind_interface is not None else ''
829        '''
830         Bind interface
831        '''
832        self.egress_filter = egress_filter if egress_filter is not None else ''
833        '''
834         A filter applied to the routing logic to pin datasource to nodes.
835        '''
836        self.enable_env_variables = enable_env_variables if enable_env_variables is not None else False
837        self.healthy = healthy if healthy is not None else False
838        '''
839         True if the datasource is reachable and the credentials are valid.
840        '''
841        self.id = id if id is not None else ''
842        '''
843         Unique identifier of the Resource.
844        '''
845        self.name = name if name is not None else ''
846        '''
847         Unique human-readable name of the Resource.
848        '''
849        self.port_override = port_override if port_override is not None else 0
850        self.region = region if region is not None else ''
851        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
852        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
853        self.role_arn = role_arn if role_arn is not None else ''
854        self.role_external_id = role_external_id if role_external_id is not None else ''
855        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
856        '''
857         ID of the secret store containing credentials for this resource, if any.
858        '''
859        self.session_expiry = session_expiry if session_expiry is not None else 0
860        self.subdomain = subdomain if subdomain is not None else ''
861        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
862        '''
863         Tags is a map of key, value pairs.
864        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

enable_env_variables
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
remote_identity_group_id
remote_identity_healthcheck_username
role_arn
role_external_id
secret_store_id

ID of the secret store containing credentials for this resource, if any.

session_expiry
subdomain
tags

Tags is a map of key, value pairs.

def to_dict(self)
886    def to_dict(self):
887        return {
888            'bind_interface': self.bind_interface,
889            'egress_filter': self.egress_filter,
890            'enable_env_variables': self.enable_env_variables,
891            'healthy': self.healthy,
892            'id': self.id,
893            'name': self.name,
894            'port_override': self.port_override,
895            'region': self.region,
896            'remote_identity_group_id': self.remote_identity_group_id,
897            'remote_identity_healthcheck_username':
898            self.remote_identity_healthcheck_username,
899            'role_arn': self.role_arn,
900            'role_external_id': self.role_external_id,
901            'secret_store_id': self.secret_store_id,
902            'session_expiry': self.session_expiry,
903            'subdomain': self.subdomain,
904            'tags': self.tags,
905        }
@classmethod
def from_dict(cls, d)
907    @classmethod
908    def from_dict(cls, d):
909        return cls(
910            bind_interface=d.get('bind_interface'),
911            egress_filter=d.get('egress_filter'),
912            enable_env_variables=d.get('enable_env_variables'),
913            healthy=d.get('healthy'),
914            id=d.get('id'),
915            name=d.get('name'),
916            port_override=d.get('port_override'),
917            region=d.get('region'),
918            remote_identity_group_id=d.get('remote_identity_group_id'),
919            remote_identity_healthcheck_username=d.get(
920                'remote_identity_healthcheck_username'),
921            role_arn=d.get('role_arn'),
922            role_external_id=d.get('role_external_id'),
923            secret_store_id=d.get('secret_store_id'),
924            session_expiry=d.get('session_expiry'),
925            subdomain=d.get('subdomain'),
926            tags=d.get('tags'),
927        )
class AWSConsoleStaticKeyPair:
 930class AWSConsoleStaticKeyPair:
 931    '''
 932    AWSConsoleStaticKeyPair is currently unstable, and its API may change, or it may be removed,
 933    without a major version bump.
 934    '''
 935    __slots__ = [
 936        'access_key',
 937        'bind_interface',
 938        'egress_filter',
 939        'healthy',
 940        'id',
 941        'name',
 942        'port_override',
 943        'region',
 944        'remote_identity_group_id',
 945        'remote_identity_healthcheck_username',
 946        'role_arn',
 947        'role_external_id',
 948        'secret_access_key',
 949        'secret_store_id',
 950        'session_expiry',
 951        'subdomain',
 952        'tags',
 953    ]
 954
 955    def __init__(
 956        self,
 957        access_key=None,
 958        bind_interface=None,
 959        egress_filter=None,
 960        healthy=None,
 961        id=None,
 962        name=None,
 963        port_override=None,
 964        region=None,
 965        remote_identity_group_id=None,
 966        remote_identity_healthcheck_username=None,
 967        role_arn=None,
 968        role_external_id=None,
 969        secret_access_key=None,
 970        secret_store_id=None,
 971        session_expiry=None,
 972        subdomain=None,
 973        tags=None,
 974    ):
 975        self.access_key = access_key if access_key is not None else ''
 976        self.bind_interface = bind_interface if bind_interface is not None else ''
 977        '''
 978         Bind interface
 979        '''
 980        self.egress_filter = egress_filter if egress_filter is not None else ''
 981        '''
 982         A filter applied to the routing logic to pin datasource to nodes.
 983        '''
 984        self.healthy = healthy if healthy is not None else False
 985        '''
 986         True if the datasource is reachable and the credentials are valid.
 987        '''
 988        self.id = id if id is not None else ''
 989        '''
 990         Unique identifier of the Resource.
 991        '''
 992        self.name = name if name is not None else ''
 993        '''
 994         Unique human-readable name of the Resource.
 995        '''
 996        self.port_override = port_override if port_override is not None else 0
 997        self.region = region if region is not None else ''
 998        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 999        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1000        self.role_arn = role_arn if role_arn is not None else ''
1001        self.role_external_id = role_external_id if role_external_id is not None else ''
1002        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1003        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1004        '''
1005         ID of the secret store containing credentials for this resource, if any.
1006        '''
1007        self.session_expiry = session_expiry if session_expiry is not None else 0
1008        self.subdomain = subdomain if subdomain is not None else ''
1009        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1010        '''
1011         Tags is a map of key, value pairs.
1012        '''
1013
1014    def __repr__(self):
1015        return '<sdm.AWSConsoleStaticKeyPair ' + \
1016            'access_key: ' + repr(self.access_key) + ' ' +\
1017            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1018            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1019            'healthy: ' + repr(self.healthy) + ' ' +\
1020            'id: ' + repr(self.id) + ' ' +\
1021            'name: ' + repr(self.name) + ' ' +\
1022            'port_override: ' + repr(self.port_override) + ' ' +\
1023            'region: ' + repr(self.region) + ' ' +\
1024            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
1025            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
1026            'role_arn: ' + repr(self.role_arn) + ' ' +\
1027            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1028            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1029            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1030            'session_expiry: ' + repr(self.session_expiry) + ' ' +\
1031            'subdomain: ' + repr(self.subdomain) + ' ' +\
1032            'tags: ' + repr(self.tags) + ' ' +\
1033            '>'
1034
1035    def to_dict(self):
1036        return {
1037            'access_key': self.access_key,
1038            'bind_interface': self.bind_interface,
1039            'egress_filter': self.egress_filter,
1040            'healthy': self.healthy,
1041            'id': self.id,
1042            'name': self.name,
1043            'port_override': self.port_override,
1044            'region': self.region,
1045            'remote_identity_group_id': self.remote_identity_group_id,
1046            'remote_identity_healthcheck_username':
1047            self.remote_identity_healthcheck_username,
1048            'role_arn': self.role_arn,
1049            'role_external_id': self.role_external_id,
1050            'secret_access_key': self.secret_access_key,
1051            'secret_store_id': self.secret_store_id,
1052            'session_expiry': self.session_expiry,
1053            'subdomain': self.subdomain,
1054            'tags': self.tags,
1055        }
1056
1057    @classmethod
1058    def from_dict(cls, d):
1059        return cls(
1060            access_key=d.get('access_key'),
1061            bind_interface=d.get('bind_interface'),
1062            egress_filter=d.get('egress_filter'),
1063            healthy=d.get('healthy'),
1064            id=d.get('id'),
1065            name=d.get('name'),
1066            port_override=d.get('port_override'),
1067            region=d.get('region'),
1068            remote_identity_group_id=d.get('remote_identity_group_id'),
1069            remote_identity_healthcheck_username=d.get(
1070                'remote_identity_healthcheck_username'),
1071            role_arn=d.get('role_arn'),
1072            role_external_id=d.get('role_external_id'),
1073            secret_access_key=d.get('secret_access_key'),
1074            secret_store_id=d.get('secret_store_id'),
1075            session_expiry=d.get('session_expiry'),
1076            subdomain=d.get('subdomain'),
1077            tags=d.get('tags'),
1078        )

AWSConsoleStaticKeyPair is currently unstable, and its API may change, or it may be removed, without a major version bump.

AWSConsoleStaticKeyPair( access_key=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, port_override=None, region=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, session_expiry=None, subdomain=None, tags=None)
 955    def __init__(
 956        self,
 957        access_key=None,
 958        bind_interface=None,
 959        egress_filter=None,
 960        healthy=None,
 961        id=None,
 962        name=None,
 963        port_override=None,
 964        region=None,
 965        remote_identity_group_id=None,
 966        remote_identity_healthcheck_username=None,
 967        role_arn=None,
 968        role_external_id=None,
 969        secret_access_key=None,
 970        secret_store_id=None,
 971        session_expiry=None,
 972        subdomain=None,
 973        tags=None,
 974    ):
 975        self.access_key = access_key if access_key is not None else ''
 976        self.bind_interface = bind_interface if bind_interface is not None else ''
 977        '''
 978         Bind interface
 979        '''
 980        self.egress_filter = egress_filter if egress_filter is not None else ''
 981        '''
 982         A filter applied to the routing logic to pin datasource to nodes.
 983        '''
 984        self.healthy = healthy if healthy is not None else False
 985        '''
 986         True if the datasource is reachable and the credentials are valid.
 987        '''
 988        self.id = id if id is not None else ''
 989        '''
 990         Unique identifier of the Resource.
 991        '''
 992        self.name = name if name is not None else ''
 993        '''
 994         Unique human-readable name of the Resource.
 995        '''
 996        self.port_override = port_override if port_override is not None else 0
 997        self.region = region if region is not None else ''
 998        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 999        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1000        self.role_arn = role_arn if role_arn is not None else ''
1001        self.role_external_id = role_external_id if role_external_id is not None else ''
1002        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1003        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1004        '''
1005         ID of the secret store containing credentials for this resource, if any.
1006        '''
1007        self.session_expiry = session_expiry if session_expiry is not None else 0
1008        self.subdomain = subdomain if subdomain is not None else ''
1009        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1010        '''
1011         Tags is a map of key, value pairs.
1012        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
remote_identity_group_id
remote_identity_healthcheck_username
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

session_expiry
subdomain
tags

Tags is a map of key, value pairs.

def to_dict(self)
1035    def to_dict(self):
1036        return {
1037            'access_key': self.access_key,
1038            'bind_interface': self.bind_interface,
1039            'egress_filter': self.egress_filter,
1040            'healthy': self.healthy,
1041            'id': self.id,
1042            'name': self.name,
1043            'port_override': self.port_override,
1044            'region': self.region,
1045            'remote_identity_group_id': self.remote_identity_group_id,
1046            'remote_identity_healthcheck_username':
1047            self.remote_identity_healthcheck_username,
1048            'role_arn': self.role_arn,
1049            'role_external_id': self.role_external_id,
1050            'secret_access_key': self.secret_access_key,
1051            'secret_store_id': self.secret_store_id,
1052            'session_expiry': self.session_expiry,
1053            'subdomain': self.subdomain,
1054            'tags': self.tags,
1055        }
@classmethod
def from_dict(cls, d)
1057    @classmethod
1058    def from_dict(cls, d):
1059        return cls(
1060            access_key=d.get('access_key'),
1061            bind_interface=d.get('bind_interface'),
1062            egress_filter=d.get('egress_filter'),
1063            healthy=d.get('healthy'),
1064            id=d.get('id'),
1065            name=d.get('name'),
1066            port_override=d.get('port_override'),
1067            region=d.get('region'),
1068            remote_identity_group_id=d.get('remote_identity_group_id'),
1069            remote_identity_healthcheck_username=d.get(
1070                'remote_identity_healthcheck_username'),
1071            role_arn=d.get('role_arn'),
1072            role_external_id=d.get('role_external_id'),
1073            secret_access_key=d.get('secret_access_key'),
1074            secret_store_id=d.get('secret_store_id'),
1075            session_expiry=d.get('session_expiry'),
1076            subdomain=d.get('subdomain'),
1077            tags=d.get('tags'),
1078        )
class AWSStore:
1081class AWSStore:
1082    __slots__ = [
1083        'id',
1084        'name',
1085        'region',
1086        'tags',
1087    ]
1088
1089    def __init__(
1090        self,
1091        id=None,
1092        name=None,
1093        region=None,
1094        tags=None,
1095    ):
1096        self.id = id if id is not None else ''
1097        '''
1098         Unique identifier of the SecretStore.
1099        '''
1100        self.name = name if name is not None else ''
1101        '''
1102         Unique human-readable name of the SecretStore.
1103        '''
1104        self.region = region if region is not None else ''
1105        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1106        '''
1107         Tags is a map of key, value pairs.
1108        '''
1109
1110    def __repr__(self):
1111        return '<sdm.AWSStore ' + \
1112            'id: ' + repr(self.id) + ' ' +\
1113            'name: ' + repr(self.name) + ' ' +\
1114            'region: ' + repr(self.region) + ' ' +\
1115            'tags: ' + repr(self.tags) + ' ' +\
1116            '>'
1117
1118    def to_dict(self):
1119        return {
1120            'id': self.id,
1121            'name': self.name,
1122            'region': self.region,
1123            'tags': self.tags,
1124        }
1125
1126    @classmethod
1127    def from_dict(cls, d):
1128        return cls(
1129            id=d.get('id'),
1130            name=d.get('name'),
1131            region=d.get('region'),
1132            tags=d.get('tags'),
1133        )
AWSStore(id=None, name=None, region=None, tags=None)
1089    def __init__(
1090        self,
1091        id=None,
1092        name=None,
1093        region=None,
1094        tags=None,
1095    ):
1096        self.id = id if id is not None else ''
1097        '''
1098         Unique identifier of the SecretStore.
1099        '''
1100        self.name = name if name is not None else ''
1101        '''
1102         Unique human-readable name of the SecretStore.
1103        '''
1104        self.region = region if region is not None else ''
1105        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1106        '''
1107         Tags is a map of key, value pairs.
1108        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

region
tags

Tags is a map of key, value pairs.

def to_dict(self)
1118    def to_dict(self):
1119        return {
1120            'id': self.id,
1121            'name': self.name,
1122            'region': self.region,
1123            'tags': self.tags,
1124        }
@classmethod
def from_dict(cls, d)
1126    @classmethod
1127    def from_dict(cls, d):
1128        return cls(
1129            id=d.get('id'),
1130            name=d.get('name'),
1131            region=d.get('region'),
1132            tags=d.get('tags'),
1133        )
class AccountAttachment:
1136class AccountAttachment:
1137    '''
1138         AccountAttachments assign an account to a role.
1139    '''
1140    __slots__ = [
1141        'account_id',
1142        'id',
1143        'role_id',
1144    ]
1145
1146    def __init__(
1147        self,
1148        account_id=None,
1149        id=None,
1150        role_id=None,
1151    ):
1152        self.account_id = account_id if account_id is not None else ''
1153        '''
1154         The id of the account of this AccountAttachment.
1155        '''
1156        self.id = id if id is not None else ''
1157        '''
1158         Unique identifier of the AccountAttachment.
1159        '''
1160        self.role_id = role_id if role_id is not None else ''
1161        '''
1162         The id of the attached role of this AccountAttachment.
1163        '''
1164
1165    def __repr__(self):
1166        return '<sdm.AccountAttachment ' + \
1167            'account_id: ' + repr(self.account_id) + ' ' +\
1168            'id: ' + repr(self.id) + ' ' +\
1169            'role_id: ' + repr(self.role_id) + ' ' +\
1170            '>'
1171
1172    def to_dict(self):
1173        return {
1174            'account_id': self.account_id,
1175            'id': self.id,
1176            'role_id': self.role_id,
1177        }
1178
1179    @classmethod
1180    def from_dict(cls, d):
1181        return cls(
1182            account_id=d.get('account_id'),
1183            id=d.get('id'),
1184            role_id=d.get('role_id'),
1185        )

AccountAttachments assign an account to a role.

AccountAttachment(account_id=None, id=None, role_id=None)
1146    def __init__(
1147        self,
1148        account_id=None,
1149        id=None,
1150        role_id=None,
1151    ):
1152        self.account_id = account_id if account_id is not None else ''
1153        '''
1154         The id of the account of this AccountAttachment.
1155        '''
1156        self.id = id if id is not None else ''
1157        '''
1158         Unique identifier of the AccountAttachment.
1159        '''
1160        self.role_id = role_id if role_id is not None else ''
1161        '''
1162         The id of the attached role of this AccountAttachment.
1163        '''
account_id

The id of the account of this AccountAttachment.

id

Unique identifier of the AccountAttachment.

role_id

The id of the attached role of this AccountAttachment.

def to_dict(self)
1172    def to_dict(self):
1173        return {
1174            'account_id': self.account_id,
1175            'id': self.id,
1176            'role_id': self.role_id,
1177        }
@classmethod
def from_dict(cls, d)
1179    @classmethod
1180    def from_dict(cls, d):
1181        return cls(
1182            account_id=d.get('account_id'),
1183            id=d.get('id'),
1184            role_id=d.get('role_id'),
1185        )
class AccountAttachmentCreateResponse:
1188class AccountAttachmentCreateResponse:
1189    '''
1190         AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
1191    '''
1192    __slots__ = [
1193        'account_attachment',
1194        'meta',
1195        'rate_limit',
1196    ]
1197
1198    def __init__(
1199        self,
1200        account_attachment=None,
1201        meta=None,
1202        rate_limit=None,
1203    ):
1204        self.account_attachment = account_attachment if account_attachment is not None else None
1205        '''
1206         The created AccountAttachment.
1207        '''
1208        self.meta = meta if meta is not None else None
1209        '''
1210         Reserved for future use.
1211        '''
1212        self.rate_limit = rate_limit if rate_limit is not None else None
1213        '''
1214         Rate limit information.
1215        '''
1216
1217    def __repr__(self):
1218        return '<sdm.AccountAttachmentCreateResponse ' + \
1219            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
1220            'meta: ' + repr(self.meta) + ' ' +\
1221            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1222            '>'
1223
1224    def to_dict(self):
1225        return {
1226            'account_attachment': self.account_attachment,
1227            'meta': self.meta,
1228            'rate_limit': self.rate_limit,
1229        }
1230
1231    @classmethod
1232    def from_dict(cls, d):
1233        return cls(
1234            account_attachment=d.get('account_attachment'),
1235            meta=d.get('meta'),
1236            rate_limit=d.get('rate_limit'),
1237        )

AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.

AccountAttachmentCreateResponse(account_attachment=None, meta=None, rate_limit=None)
1198    def __init__(
1199        self,
1200        account_attachment=None,
1201        meta=None,
1202        rate_limit=None,
1203    ):
1204        self.account_attachment = account_attachment if account_attachment is not None else None
1205        '''
1206         The created AccountAttachment.
1207        '''
1208        self.meta = meta if meta is not None else None
1209        '''
1210         Reserved for future use.
1211        '''
1212        self.rate_limit = rate_limit if rate_limit is not None else None
1213        '''
1214         Rate limit information.
1215        '''
account_attachment

The created AccountAttachment.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1224    def to_dict(self):
1225        return {
1226            'account_attachment': self.account_attachment,
1227            'meta': self.meta,
1228            'rate_limit': self.rate_limit,
1229        }
@classmethod
def from_dict(cls, d)
1231    @classmethod
1232    def from_dict(cls, d):
1233        return cls(
1234            account_attachment=d.get('account_attachment'),
1235            meta=d.get('meta'),
1236            rate_limit=d.get('rate_limit'),
1237        )
class AccountAttachmentDeleteResponse:
1240class AccountAttachmentDeleteResponse:
1241    '''
1242         AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
1243    '''
1244    __slots__ = [
1245        'meta',
1246        'rate_limit',
1247    ]
1248
1249    def __init__(
1250        self,
1251        meta=None,
1252        rate_limit=None,
1253    ):
1254        self.meta = meta if meta is not None else None
1255        '''
1256         Reserved for future use.
1257        '''
1258        self.rate_limit = rate_limit if rate_limit is not None else None
1259        '''
1260         Rate limit information.
1261        '''
1262
1263    def __repr__(self):
1264        return '<sdm.AccountAttachmentDeleteResponse ' + \
1265            'meta: ' + repr(self.meta) + ' ' +\
1266            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1267            '>'
1268
1269    def to_dict(self):
1270        return {
1271            'meta': self.meta,
1272            'rate_limit': self.rate_limit,
1273        }
1274
1275    @classmethod
1276    def from_dict(cls, d):
1277        return cls(
1278            meta=d.get('meta'),
1279            rate_limit=d.get('rate_limit'),
1280        )

AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.

AccountAttachmentDeleteResponse(meta=None, rate_limit=None)
1249    def __init__(
1250        self,
1251        meta=None,
1252        rate_limit=None,
1253    ):
1254        self.meta = meta if meta is not None else None
1255        '''
1256         Reserved for future use.
1257        '''
1258        self.rate_limit = rate_limit if rate_limit is not None else None
1259        '''
1260         Rate limit information.
1261        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1269    def to_dict(self):
1270        return {
1271            'meta': self.meta,
1272            'rate_limit': self.rate_limit,
1273        }
@classmethod
def from_dict(cls, d)
1275    @classmethod
1276    def from_dict(cls, d):
1277        return cls(
1278            meta=d.get('meta'),
1279            rate_limit=d.get('rate_limit'),
1280        )
class AccountAttachmentGetResponse:
1283class AccountAttachmentGetResponse:
1284    '''
1285         AccountAttachmentGetResponse returns a requested AccountAttachment.
1286    '''
1287    __slots__ = [
1288        'account_attachment',
1289        'meta',
1290        'rate_limit',
1291    ]
1292
1293    def __init__(
1294        self,
1295        account_attachment=None,
1296        meta=None,
1297        rate_limit=None,
1298    ):
1299        self.account_attachment = account_attachment if account_attachment is not None else None
1300        '''
1301         The requested AccountAttachment.
1302        '''
1303        self.meta = meta if meta is not None else None
1304        '''
1305         Reserved for future use.
1306        '''
1307        self.rate_limit = rate_limit if rate_limit is not None else None
1308        '''
1309         Rate limit information.
1310        '''
1311
1312    def __repr__(self):
1313        return '<sdm.AccountAttachmentGetResponse ' + \
1314            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
1315            'meta: ' + repr(self.meta) + ' ' +\
1316            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1317            '>'
1318
1319    def to_dict(self):
1320        return {
1321            'account_attachment': self.account_attachment,
1322            'meta': self.meta,
1323            'rate_limit': self.rate_limit,
1324        }
1325
1326    @classmethod
1327    def from_dict(cls, d):
1328        return cls(
1329            account_attachment=d.get('account_attachment'),
1330            meta=d.get('meta'),
1331            rate_limit=d.get('rate_limit'),
1332        )

AccountAttachmentGetResponse returns a requested AccountAttachment.

AccountAttachmentGetResponse(account_attachment=None, meta=None, rate_limit=None)
1293    def __init__(
1294        self,
1295        account_attachment=None,
1296        meta=None,
1297        rate_limit=None,
1298    ):
1299        self.account_attachment = account_attachment if account_attachment is not None else None
1300        '''
1301         The requested AccountAttachment.
1302        '''
1303        self.meta = meta if meta is not None else None
1304        '''
1305         Reserved for future use.
1306        '''
1307        self.rate_limit = rate_limit if rate_limit is not None else None
1308        '''
1309         Rate limit information.
1310        '''
account_attachment

The requested AccountAttachment.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1319    def to_dict(self):
1320        return {
1321            'account_attachment': self.account_attachment,
1322            'meta': self.meta,
1323            'rate_limit': self.rate_limit,
1324        }
@classmethod
def from_dict(cls, d)
1326    @classmethod
1327    def from_dict(cls, d):
1328        return cls(
1329            account_attachment=d.get('account_attachment'),
1330            meta=d.get('meta'),
1331            rate_limit=d.get('rate_limit'),
1332        )
class AccountCreateResponse:
1335class AccountCreateResponse:
1336    '''
1337         AccountCreateResponse reports how the Accounts were created in the system.
1338    '''
1339    __slots__ = [
1340        'account',
1341        'meta',
1342        'rate_limit',
1343        'token',
1344    ]
1345
1346    def __init__(
1347        self,
1348        account=None,
1349        meta=None,
1350        rate_limit=None,
1351        token=None,
1352    ):
1353        self.account = account if account is not None else None
1354        '''
1355         The created Account.
1356        '''
1357        self.meta = meta if meta is not None else None
1358        '''
1359         Reserved for future use.
1360        '''
1361        self.rate_limit = rate_limit if rate_limit is not None else None
1362        '''
1363         Rate limit information.
1364        '''
1365        self.token = token if token is not None else ''
1366        '''
1367         The auth token generated for the Account. The Account will use this token to
1368         authenticate with the strongDM API.
1369        '''
1370
1371    def __repr__(self):
1372        return '<sdm.AccountCreateResponse ' + \
1373            'account: ' + repr(self.account) + ' ' +\
1374            'meta: ' + repr(self.meta) + ' ' +\
1375            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1376            'token: ' + repr(self.token) + ' ' +\
1377            '>'
1378
1379    def to_dict(self):
1380        return {
1381            'account': self.account,
1382            'meta': self.meta,
1383            'rate_limit': self.rate_limit,
1384            'token': self.token,
1385        }
1386
1387    @classmethod
1388    def from_dict(cls, d):
1389        return cls(
1390            account=d.get('account'),
1391            meta=d.get('meta'),
1392            rate_limit=d.get('rate_limit'),
1393            token=d.get('token'),
1394        )

AccountCreateResponse reports how the Accounts were created in the system.

AccountCreateResponse(account=None, meta=None, rate_limit=None, token=None)
1346    def __init__(
1347        self,
1348        account=None,
1349        meta=None,
1350        rate_limit=None,
1351        token=None,
1352    ):
1353        self.account = account if account is not None else None
1354        '''
1355         The created Account.
1356        '''
1357        self.meta = meta if meta is not None else None
1358        '''
1359         Reserved for future use.
1360        '''
1361        self.rate_limit = rate_limit if rate_limit is not None else None
1362        '''
1363         Rate limit information.
1364        '''
1365        self.token = token if token is not None else ''
1366        '''
1367         The auth token generated for the Account. The Account will use this token to
1368         authenticate with the strongDM API.
1369        '''
account

The created Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

token

The auth token generated for the Account. The Account will use this token to authenticate with the strongDM API.

def to_dict(self)
1379    def to_dict(self):
1380        return {
1381            'account': self.account,
1382            'meta': self.meta,
1383            'rate_limit': self.rate_limit,
1384            'token': self.token,
1385        }
@classmethod
def from_dict(cls, d)
1387    @classmethod
1388    def from_dict(cls, d):
1389        return cls(
1390            account=d.get('account'),
1391            meta=d.get('meta'),
1392            rate_limit=d.get('rate_limit'),
1393            token=d.get('token'),
1394        )
class AccountDeleteResponse:
1397class AccountDeleteResponse:
1398    '''
1399         AccountDeleteResponse returns information about a Account that was deleted.
1400    '''
1401    __slots__ = [
1402        'meta',
1403        'rate_limit',
1404    ]
1405
1406    def __init__(
1407        self,
1408        meta=None,
1409        rate_limit=None,
1410    ):
1411        self.meta = meta if meta is not None else None
1412        '''
1413         Reserved for future use.
1414        '''
1415        self.rate_limit = rate_limit if rate_limit is not None else None
1416        '''
1417         Rate limit information.
1418        '''
1419
1420    def __repr__(self):
1421        return '<sdm.AccountDeleteResponse ' + \
1422            'meta: ' + repr(self.meta) + ' ' +\
1423            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1424            '>'
1425
1426    def to_dict(self):
1427        return {
1428            'meta': self.meta,
1429            'rate_limit': self.rate_limit,
1430        }
1431
1432    @classmethod
1433    def from_dict(cls, d):
1434        return cls(
1435            meta=d.get('meta'),
1436            rate_limit=d.get('rate_limit'),
1437        )

AccountDeleteResponse returns information about a Account that was deleted.

AccountDeleteResponse(meta=None, rate_limit=None)
1406    def __init__(
1407        self,
1408        meta=None,
1409        rate_limit=None,
1410    ):
1411        self.meta = meta if meta is not None else None
1412        '''
1413         Reserved for future use.
1414        '''
1415        self.rate_limit = rate_limit if rate_limit is not None else None
1416        '''
1417         Rate limit information.
1418        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1426    def to_dict(self):
1427        return {
1428            'meta': self.meta,
1429            'rate_limit': self.rate_limit,
1430        }
@classmethod
def from_dict(cls, d)
1432    @classmethod
1433    def from_dict(cls, d):
1434        return cls(
1435            meta=d.get('meta'),
1436            rate_limit=d.get('rate_limit'),
1437        )
class AccountGetResponse:
1440class AccountGetResponse:
1441    '''
1442         AccountGetResponse returns a requested Account.
1443    '''
1444    __slots__ = [
1445        'account',
1446        'meta',
1447        'rate_limit',
1448    ]
1449
1450    def __init__(
1451        self,
1452        account=None,
1453        meta=None,
1454        rate_limit=None,
1455    ):
1456        self.account = account if account is not None else None
1457        '''
1458         The requested Account.
1459        '''
1460        self.meta = meta if meta is not None else None
1461        '''
1462         Reserved for future use.
1463        '''
1464        self.rate_limit = rate_limit if rate_limit is not None else None
1465        '''
1466         Rate limit information.
1467        '''
1468
1469    def __repr__(self):
1470        return '<sdm.AccountGetResponse ' + \
1471            'account: ' + repr(self.account) + ' ' +\
1472            'meta: ' + repr(self.meta) + ' ' +\
1473            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1474            '>'
1475
1476    def to_dict(self):
1477        return {
1478            'account': self.account,
1479            'meta': self.meta,
1480            'rate_limit': self.rate_limit,
1481        }
1482
1483    @classmethod
1484    def from_dict(cls, d):
1485        return cls(
1486            account=d.get('account'),
1487            meta=d.get('meta'),
1488            rate_limit=d.get('rate_limit'),
1489        )

AccountGetResponse returns a requested Account.

AccountGetResponse(account=None, meta=None, rate_limit=None)
1450    def __init__(
1451        self,
1452        account=None,
1453        meta=None,
1454        rate_limit=None,
1455    ):
1456        self.account = account if account is not None else None
1457        '''
1458         The requested Account.
1459        '''
1460        self.meta = meta if meta is not None else None
1461        '''
1462         Reserved for future use.
1463        '''
1464        self.rate_limit = rate_limit if rate_limit is not None else None
1465        '''
1466         Rate limit information.
1467        '''
account

The requested Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1476    def to_dict(self):
1477        return {
1478            'account': self.account,
1479            'meta': self.meta,
1480            'rate_limit': self.rate_limit,
1481        }
@classmethod
def from_dict(cls, d)
1483    @classmethod
1484    def from_dict(cls, d):
1485        return cls(
1486            account=d.get('account'),
1487            meta=d.get('meta'),
1488            rate_limit=d.get('rate_limit'),
1489        )
class AccountGrant:
1492class AccountGrant:
1493    '''
1494         AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
1495    '''
1496    __slots__ = [
1497        'account_id',
1498        'id',
1499        'resource_id',
1500        'start_from',
1501        'valid_until',
1502    ]
1503
1504    def __init__(
1505        self,
1506        account_id=None,
1507        id=None,
1508        resource_id=None,
1509        start_from=None,
1510        valid_until=None,
1511    ):
1512        self.account_id = account_id if account_id is not None else ''
1513        '''
1514         The account ID of this AccountGrant.
1515        '''
1516        self.id = id if id is not None else ''
1517        '''
1518         Unique identifier of the AccountGrant.
1519        '''
1520        self.resource_id = resource_id if resource_id is not None else ''
1521        '''
1522         The resource ID of this AccountGrant.
1523        '''
1524        self.start_from = start_from if start_from is not None else None
1525        '''
1526         The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.
1527        '''
1528        self.valid_until = valid_until if valid_until is not None else None
1529        '''
1530         The timestamp when the resource grant will expire.
1531        '''
1532
1533    def __repr__(self):
1534        return '<sdm.AccountGrant ' + \
1535            'account_id: ' + repr(self.account_id) + ' ' +\
1536            'id: ' + repr(self.id) + ' ' +\
1537            'resource_id: ' + repr(self.resource_id) + ' ' +\
1538            'start_from: ' + repr(self.start_from) + ' ' +\
1539            'valid_until: ' + repr(self.valid_until) + ' ' +\
1540            '>'
1541
1542    def to_dict(self):
1543        return {
1544            'account_id': self.account_id,
1545            'id': self.id,
1546            'resource_id': self.resource_id,
1547            'start_from': self.start_from,
1548            'valid_until': self.valid_until,
1549        }
1550
1551    @classmethod
1552    def from_dict(cls, d):
1553        return cls(
1554            account_id=d.get('account_id'),
1555            id=d.get('id'),
1556            resource_id=d.get('resource_id'),
1557            start_from=d.get('start_from'),
1558            valid_until=d.get('valid_until'),
1559        )

AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.

AccountGrant( account_id=None, id=None, resource_id=None, start_from=None, valid_until=None)
1504    def __init__(
1505        self,
1506        account_id=None,
1507        id=None,
1508        resource_id=None,
1509        start_from=None,
1510        valid_until=None,
1511    ):
1512        self.account_id = account_id if account_id is not None else ''
1513        '''
1514         The account ID of this AccountGrant.
1515        '''
1516        self.id = id if id is not None else ''
1517        '''
1518         Unique identifier of the AccountGrant.
1519        '''
1520        self.resource_id = resource_id if resource_id is not None else ''
1521        '''
1522         The resource ID of this AccountGrant.
1523        '''
1524        self.start_from = start_from if start_from is not None else None
1525        '''
1526         The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.
1527        '''
1528        self.valid_until = valid_until if valid_until is not None else None
1529        '''
1530         The timestamp when the resource grant will expire.
1531        '''
account_id

The account ID of this AccountGrant.

id

Unique identifier of the AccountGrant.

resource_id

The resource ID of this AccountGrant.

start_from

The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.

valid_until

The timestamp when the resource grant will expire.

def to_dict(self)
1542    def to_dict(self):
1543        return {
1544            'account_id': self.account_id,
1545            'id': self.id,
1546            'resource_id': self.resource_id,
1547            'start_from': self.start_from,
1548            'valid_until': self.valid_until,
1549        }
@classmethod
def from_dict(cls, d)
1551    @classmethod
1552    def from_dict(cls, d):
1553        return cls(
1554            account_id=d.get('account_id'),
1555            id=d.get('id'),
1556            resource_id=d.get('resource_id'),
1557            start_from=d.get('start_from'),
1558            valid_until=d.get('valid_until'),
1559        )
class AccountGrantCreateResponse:
1562class AccountGrantCreateResponse:
1563    '''
1564         AccountGrantCreateResponse reports how the AccountGrants were created in the system.
1565    '''
1566    __slots__ = [
1567        'account_grant',
1568        'meta',
1569        'rate_limit',
1570    ]
1571
1572    def __init__(
1573        self,
1574        account_grant=None,
1575        meta=None,
1576        rate_limit=None,
1577    ):
1578        self.account_grant = account_grant if account_grant is not None else None
1579        '''
1580         The created AccountGrant.
1581        '''
1582        self.meta = meta if meta is not None else None
1583        '''
1584         Reserved for future use.
1585        '''
1586        self.rate_limit = rate_limit if rate_limit is not None else None
1587        '''
1588         Rate limit information.
1589        '''
1590
1591    def __repr__(self):
1592        return '<sdm.AccountGrantCreateResponse ' + \
1593            'account_grant: ' + repr(self.account_grant) + ' ' +\
1594            'meta: ' + repr(self.meta) + ' ' +\
1595            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1596            '>'
1597
1598    def to_dict(self):
1599        return {
1600            'account_grant': self.account_grant,
1601            'meta': self.meta,
1602            'rate_limit': self.rate_limit,
1603        }
1604
1605    @classmethod
1606    def from_dict(cls, d):
1607        return cls(
1608            account_grant=d.get('account_grant'),
1609            meta=d.get('meta'),
1610            rate_limit=d.get('rate_limit'),
1611        )

AccountGrantCreateResponse reports how the AccountGrants were created in the system.

AccountGrantCreateResponse(account_grant=None, meta=None, rate_limit=None)
1572    def __init__(
1573        self,
1574        account_grant=None,
1575        meta=None,
1576        rate_limit=None,
1577    ):
1578        self.account_grant = account_grant if account_grant is not None else None
1579        '''
1580         The created AccountGrant.
1581        '''
1582        self.meta = meta if meta is not None else None
1583        '''
1584         Reserved for future use.
1585        '''
1586        self.rate_limit = rate_limit if rate_limit is not None else None
1587        '''
1588         Rate limit information.
1589        '''
account_grant

The created AccountGrant.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1598    def to_dict(self):
1599        return {
1600            'account_grant': self.account_grant,
1601            'meta': self.meta,
1602            'rate_limit': self.rate_limit,
1603        }
@classmethod
def from_dict(cls, d)
1605    @classmethod
1606    def from_dict(cls, d):
1607        return cls(
1608            account_grant=d.get('account_grant'),
1609            meta=d.get('meta'),
1610            rate_limit=d.get('rate_limit'),
1611        )
class AccountGrantDeleteResponse:
1614class AccountGrantDeleteResponse:
1615    '''
1616         AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
1617    '''
1618    __slots__ = [
1619        'meta',
1620        'rate_limit',
1621    ]
1622
1623    def __init__(
1624        self,
1625        meta=None,
1626        rate_limit=None,
1627    ):
1628        self.meta = meta if meta is not None else None
1629        '''
1630         Reserved for future use.
1631        '''
1632        self.rate_limit = rate_limit if rate_limit is not None else None
1633        '''
1634         Rate limit information.
1635        '''
1636
1637    def __repr__(self):
1638        return '<sdm.AccountGrantDeleteResponse ' + \
1639            'meta: ' + repr(self.meta) + ' ' +\
1640            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1641            '>'
1642
1643    def to_dict(self):
1644        return {
1645            'meta': self.meta,
1646            'rate_limit': self.rate_limit,
1647        }
1648
1649    @classmethod
1650    def from_dict(cls, d):
1651        return cls(
1652            meta=d.get('meta'),
1653            rate_limit=d.get('rate_limit'),
1654        )

AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.

AccountGrantDeleteResponse(meta=None, rate_limit=None)
1623    def __init__(
1624        self,
1625        meta=None,
1626        rate_limit=None,
1627    ):
1628        self.meta = meta if meta is not None else None
1629        '''
1630         Reserved for future use.
1631        '''
1632        self.rate_limit = rate_limit if rate_limit is not None else None
1633        '''
1634         Rate limit information.
1635        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1643    def to_dict(self):
1644        return {
1645            'meta': self.meta,
1646            'rate_limit': self.rate_limit,
1647        }
@classmethod
def from_dict(cls, d)
1649    @classmethod
1650    def from_dict(cls, d):
1651        return cls(
1652            meta=d.get('meta'),
1653            rate_limit=d.get('rate_limit'),
1654        )
class AccountGrantGetResponse:
1657class AccountGrantGetResponse:
1658    '''
1659         AccountGrantGetResponse returns a requested AccountGrant.
1660    '''
1661    __slots__ = [
1662        'account_grant',
1663        'meta',
1664        'rate_limit',
1665    ]
1666
1667    def __init__(
1668        self,
1669        account_grant=None,
1670        meta=None,
1671        rate_limit=None,
1672    ):
1673        self.account_grant = account_grant if account_grant is not None else None
1674        '''
1675         The requested AccountGrant.
1676        '''
1677        self.meta = meta if meta is not None else None
1678        '''
1679         Reserved for future use.
1680        '''
1681        self.rate_limit = rate_limit if rate_limit is not None else None
1682        '''
1683         Rate limit information.
1684        '''
1685
1686    def __repr__(self):
1687        return '<sdm.AccountGrantGetResponse ' + \
1688            'account_grant: ' + repr(self.account_grant) + ' ' +\
1689            'meta: ' + repr(self.meta) + ' ' +\
1690            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1691            '>'
1692
1693    def to_dict(self):
1694        return {
1695            'account_grant': self.account_grant,
1696            'meta': self.meta,
1697            'rate_limit': self.rate_limit,
1698        }
1699
1700    @classmethod
1701    def from_dict(cls, d):
1702        return cls(
1703            account_grant=d.get('account_grant'),
1704            meta=d.get('meta'),
1705            rate_limit=d.get('rate_limit'),
1706        )

AccountGrantGetResponse returns a requested AccountGrant.

AccountGrantGetResponse(account_grant=None, meta=None, rate_limit=None)
1667    def __init__(
1668        self,
1669        account_grant=None,
1670        meta=None,
1671        rate_limit=None,
1672    ):
1673        self.account_grant = account_grant if account_grant is not None else None
1674        '''
1675         The requested AccountGrant.
1676        '''
1677        self.meta = meta if meta is not None else None
1678        '''
1679         Reserved for future use.
1680        '''
1681        self.rate_limit = rate_limit if rate_limit is not None else None
1682        '''
1683         Rate limit information.
1684        '''
account_grant

The requested AccountGrant.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1693    def to_dict(self):
1694        return {
1695            'account_grant': self.account_grant,
1696            'meta': self.meta,
1697            'rate_limit': self.rate_limit,
1698        }
@classmethod
def from_dict(cls, d)
1700    @classmethod
1701    def from_dict(cls, d):
1702        return cls(
1703            account_grant=d.get('account_grant'),
1704            meta=d.get('meta'),
1705            rate_limit=d.get('rate_limit'),
1706        )
class AccountUpdateResponse:
1709class AccountUpdateResponse:
1710    '''
1711         AccountUpdateResponse returns the fields of a Account after it has been updated by
1712     a AccountUpdateRequest.
1713    '''
1714    __slots__ = [
1715        'account',
1716        'meta',
1717        'rate_limit',
1718    ]
1719
1720    def __init__(
1721        self,
1722        account=None,
1723        meta=None,
1724        rate_limit=None,
1725    ):
1726        self.account = account if account is not None else None
1727        '''
1728         The updated Account.
1729        '''
1730        self.meta = meta if meta is not None else None
1731        '''
1732         Reserved for future use.
1733        '''
1734        self.rate_limit = rate_limit if rate_limit is not None else None
1735        '''
1736         Rate limit information.
1737        '''
1738
1739    def __repr__(self):
1740        return '<sdm.AccountUpdateResponse ' + \
1741            'account: ' + repr(self.account) + ' ' +\
1742            'meta: ' + repr(self.meta) + ' ' +\
1743            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1744            '>'
1745
1746    def to_dict(self):
1747        return {
1748            'account': self.account,
1749            'meta': self.meta,
1750            'rate_limit': self.rate_limit,
1751        }
1752
1753    @classmethod
1754    def from_dict(cls, d):
1755        return cls(
1756            account=d.get('account'),
1757            meta=d.get('meta'),
1758            rate_limit=d.get('rate_limit'),
1759        )

AccountUpdateResponse returns the fields of a Account after it has been updated by a AccountUpdateRequest.

AccountUpdateResponse(account=None, meta=None, rate_limit=None)
1720    def __init__(
1721        self,
1722        account=None,
1723        meta=None,
1724        rate_limit=None,
1725    ):
1726        self.account = account if account is not None else None
1727        '''
1728         The updated Account.
1729        '''
1730        self.meta = meta if meta is not None else None
1731        '''
1732         Reserved for future use.
1733        '''
1734        self.rate_limit = rate_limit if rate_limit is not None else None
1735        '''
1736         Rate limit information.
1737        '''
account

The updated Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1746    def to_dict(self):
1747        return {
1748            'account': self.account,
1749            'meta': self.meta,
1750            'rate_limit': self.rate_limit,
1751        }
@classmethod
def from_dict(cls, d)
1753    @classmethod
1754    def from_dict(cls, d):
1755        return cls(
1756            account=d.get('account'),
1757            meta=d.get('meta'),
1758            rate_limit=d.get('rate_limit'),
1759        )
class AmazonEKS:
1762class AmazonEKS:
1763    __slots__ = [
1764        'access_key',
1765        'bind_interface',
1766        'certificate_authority',
1767        'cluster_name',
1768        'egress_filter',
1769        'endpoint',
1770        'healthcheck_namespace',
1771        'healthy',
1772        'id',
1773        'name',
1774        'region',
1775        'remote_identity_group_id',
1776        'remote_identity_healthcheck_username',
1777        'role_arn',
1778        'role_external_id',
1779        'secret_access_key',
1780        'secret_store_id',
1781        'tags',
1782    ]
1783
1784    def __init__(
1785        self,
1786        access_key=None,
1787        bind_interface=None,
1788        certificate_authority=None,
1789        cluster_name=None,
1790        egress_filter=None,
1791        endpoint=None,
1792        healthcheck_namespace=None,
1793        healthy=None,
1794        id=None,
1795        name=None,
1796        region=None,
1797        remote_identity_group_id=None,
1798        remote_identity_healthcheck_username=None,
1799        role_arn=None,
1800        role_external_id=None,
1801        secret_access_key=None,
1802        secret_store_id=None,
1803        tags=None,
1804    ):
1805        self.access_key = access_key if access_key is not None else ''
1806        self.bind_interface = bind_interface if bind_interface is not None else ''
1807        '''
1808         Bind interface
1809        '''
1810        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1811        self.cluster_name = cluster_name if cluster_name is not None else ''
1812        self.egress_filter = egress_filter if egress_filter is not None else ''
1813        '''
1814         A filter applied to the routing logic to pin datasource to nodes.
1815        '''
1816        self.endpoint = endpoint if endpoint is not None else ''
1817        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1818        '''
1819         The path used to check the health of your connection.  Defaults to `default`.
1820        '''
1821        self.healthy = healthy if healthy is not None else False
1822        '''
1823         True if the datasource is reachable and the credentials are valid.
1824        '''
1825        self.id = id if id is not None else ''
1826        '''
1827         Unique identifier of the Resource.
1828        '''
1829        self.name = name if name is not None else ''
1830        '''
1831         Unique human-readable name of the Resource.
1832        '''
1833        self.region = region if region is not None else ''
1834        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
1835        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1836        self.role_arn = role_arn if role_arn is not None else ''
1837        self.role_external_id = role_external_id if role_external_id is not None else ''
1838        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1839        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1840        '''
1841         ID of the secret store containing credentials for this resource, if any.
1842        '''
1843        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1844        '''
1845         Tags is a map of key, value pairs.
1846        '''
1847
1848    def __repr__(self):
1849        return '<sdm.AmazonEKS ' + \
1850            'access_key: ' + repr(self.access_key) + ' ' +\
1851            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1852            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
1853            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
1854            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1855            'endpoint: ' + repr(self.endpoint) + ' ' +\
1856            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
1857            'healthy: ' + repr(self.healthy) + ' ' +\
1858            'id: ' + repr(self.id) + ' ' +\
1859            'name: ' + repr(self.name) + ' ' +\
1860            'region: ' + repr(self.region) + ' ' +\
1861            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
1862            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
1863            'role_arn: ' + repr(self.role_arn) + ' ' +\
1864            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1865            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1866            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1867            'tags: ' + repr(self.tags) + ' ' +\
1868            '>'
1869
1870    def to_dict(self):
1871        return {
1872            'access_key': self.access_key,
1873            'bind_interface': self.bind_interface,
1874            'certificate_authority': self.certificate_authority,
1875            'cluster_name': self.cluster_name,
1876            'egress_filter': self.egress_filter,
1877            'endpoint': self.endpoint,
1878            'healthcheck_namespace': self.healthcheck_namespace,
1879            'healthy': self.healthy,
1880            'id': self.id,
1881            'name': self.name,
1882            'region': self.region,
1883            'remote_identity_group_id': self.remote_identity_group_id,
1884            'remote_identity_healthcheck_username':
1885            self.remote_identity_healthcheck_username,
1886            'role_arn': self.role_arn,
1887            'role_external_id': self.role_external_id,
1888            'secret_access_key': self.secret_access_key,
1889            'secret_store_id': self.secret_store_id,
1890            'tags': self.tags,
1891        }
1892
1893    @classmethod
1894    def from_dict(cls, d):
1895        return cls(
1896            access_key=d.get('access_key'),
1897            bind_interface=d.get('bind_interface'),
1898            certificate_authority=d.get('certificate_authority'),
1899            cluster_name=d.get('cluster_name'),
1900            egress_filter=d.get('egress_filter'),
1901            endpoint=d.get('endpoint'),
1902            healthcheck_namespace=d.get('healthcheck_namespace'),
1903            healthy=d.get('healthy'),
1904            id=d.get('id'),
1905            name=d.get('name'),
1906            region=d.get('region'),
1907            remote_identity_group_id=d.get('remote_identity_group_id'),
1908            remote_identity_healthcheck_username=d.get(
1909                'remote_identity_healthcheck_username'),
1910            role_arn=d.get('role_arn'),
1911            role_external_id=d.get('role_external_id'),
1912            secret_access_key=d.get('secret_access_key'),
1913            secret_store_id=d.get('secret_store_id'),
1914            tags=d.get('tags'),
1915        )
AmazonEKS( access_key=None, bind_interface=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1784    def __init__(
1785        self,
1786        access_key=None,
1787        bind_interface=None,
1788        certificate_authority=None,
1789        cluster_name=None,
1790        egress_filter=None,
1791        endpoint=None,
1792        healthcheck_namespace=None,
1793        healthy=None,
1794        id=None,
1795        name=None,
1796        region=None,
1797        remote_identity_group_id=None,
1798        remote_identity_healthcheck_username=None,
1799        role_arn=None,
1800        role_external_id=None,
1801        secret_access_key=None,
1802        secret_store_id=None,
1803        tags=None,
1804    ):
1805        self.access_key = access_key if access_key is not None else ''
1806        self.bind_interface = bind_interface if bind_interface is not None else ''
1807        '''
1808         Bind interface
1809        '''
1810        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1811        self.cluster_name = cluster_name if cluster_name is not None else ''
1812        self.egress_filter = egress_filter if egress_filter is not None else ''
1813        '''
1814         A filter applied to the routing logic to pin datasource to nodes.
1815        '''
1816        self.endpoint = endpoint if endpoint is not None else ''
1817        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1818        '''
1819         The path used to check the health of your connection.  Defaults to `default`.
1820        '''
1821        self.healthy = healthy if healthy is not None else False
1822        '''
1823         True if the datasource is reachable and the credentials are valid.
1824        '''
1825        self.id = id if id is not None else ''
1826        '''
1827         Unique identifier of the Resource.
1828        '''
1829        self.name = name if name is not None else ''
1830        '''
1831         Unique human-readable name of the Resource.
1832        '''
1833        self.region = region if region is not None else ''
1834        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
1835        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1836        self.role_arn = role_arn if role_arn is not None else ''
1837        self.role_external_id = role_external_id if role_external_id is not None else ''
1838        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1839        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1840        '''
1841         ID of the secret store containing credentials for this resource, if any.
1842        '''
1843        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1844        '''
1845         Tags is a map of key, value pairs.
1846        '''
access_key
bind_interface

Bind interface

certificate_authority
cluster_name
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

region
remote_identity_group_id
remote_identity_healthcheck_username
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
1870    def to_dict(self):
1871        return {
1872            'access_key': self.access_key,
1873            'bind_interface': self.bind_interface,
1874            'certificate_authority': self.certificate_authority,
1875            'cluster_name': self.cluster_name,
1876            'egress_filter': self.egress_filter,
1877            'endpoint': self.endpoint,
1878            'healthcheck_namespace': self.healthcheck_namespace,
1879            'healthy': self.healthy,
1880            'id': self.id,
1881            'name': self.name,
1882            'region': self.region,
1883            'remote_identity_group_id': self.remote_identity_group_id,
1884            'remote_identity_healthcheck_username':
1885            self.remote_identity_healthcheck_username,
1886            'role_arn': self.role_arn,
1887            'role_external_id': self.role_external_id,
1888            'secret_access_key': self.secret_access_key,
1889            'secret_store_id': self.secret_store_id,
1890            'tags': self.tags,
1891        }
@classmethod
def from_dict(cls, d)
1893    @classmethod
1894    def from_dict(cls, d):
1895        return cls(
1896            access_key=d.get('access_key'),
1897            bind_interface=d.get('bind_interface'),
1898            certificate_authority=d.get('certificate_authority'),
1899            cluster_name=d.get('cluster_name'),
1900            egress_filter=d.get('egress_filter'),
1901            endpoint=d.get('endpoint'),
1902            healthcheck_namespace=d.get('healthcheck_namespace'),
1903            healthy=d.get('healthy'),
1904            id=d.get('id'),
1905            name=d.get('name'),
1906            region=d.get('region'),
1907            remote_identity_group_id=d.get('remote_identity_group_id'),
1908            remote_identity_healthcheck_username=d.get(
1909                'remote_identity_healthcheck_username'),
1910            role_arn=d.get('role_arn'),
1911            role_external_id=d.get('role_external_id'),
1912            secret_access_key=d.get('secret_access_key'),
1913            secret_store_id=d.get('secret_store_id'),
1914            tags=d.get('tags'),
1915        )
class AmazonEKSUserImpersonation:
1918class AmazonEKSUserImpersonation:
1919    __slots__ = [
1920        'access_key',
1921        'bind_interface',
1922        'certificate_authority',
1923        'cluster_name',
1924        'egress_filter',
1925        'endpoint',
1926        'healthcheck_namespace',
1927        'healthy',
1928        'id',
1929        'name',
1930        'region',
1931        'role_arn',
1932        'role_external_id',
1933        'secret_access_key',
1934        'secret_store_id',
1935        'tags',
1936    ]
1937
1938    def __init__(
1939        self,
1940        access_key=None,
1941        bind_interface=None,
1942        certificate_authority=None,
1943        cluster_name=None,
1944        egress_filter=None,
1945        endpoint=None,
1946        healthcheck_namespace=None,
1947        healthy=None,
1948        id=None,
1949        name=None,
1950        region=None,
1951        role_arn=None,
1952        role_external_id=None,
1953        secret_access_key=None,
1954        secret_store_id=None,
1955        tags=None,
1956    ):
1957        self.access_key = access_key if access_key is not None else ''
1958        self.bind_interface = bind_interface if bind_interface is not None else ''
1959        '''
1960         Bind interface
1961        '''
1962        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1963        self.cluster_name = cluster_name if cluster_name is not None else ''
1964        self.egress_filter = egress_filter if egress_filter is not None else ''
1965        '''
1966         A filter applied to the routing logic to pin datasource to nodes.
1967        '''
1968        self.endpoint = endpoint if endpoint is not None else ''
1969        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1970        '''
1971         The path used to check the health of your connection.  Defaults to `default`.
1972        '''
1973        self.healthy = healthy if healthy is not None else False
1974        '''
1975         True if the datasource is reachable and the credentials are valid.
1976        '''
1977        self.id = id if id is not None else ''
1978        '''
1979         Unique identifier of the Resource.
1980        '''
1981        self.name = name if name is not None else ''
1982        '''
1983         Unique human-readable name of the Resource.
1984        '''
1985        self.region = region if region is not None else ''
1986        self.role_arn = role_arn if role_arn is not None else ''
1987        self.role_external_id = role_external_id if role_external_id is not None else ''
1988        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1989        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1990        '''
1991         ID of the secret store containing credentials for this resource, if any.
1992        '''
1993        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1994        '''
1995         Tags is a map of key, value pairs.
1996        '''
1997
1998    def __repr__(self):
1999        return '<sdm.AmazonEKSUserImpersonation ' + \
2000            'access_key: ' + repr(self.access_key) + ' ' +\
2001            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2002            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
2003            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
2004            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2005            'endpoint: ' + repr(self.endpoint) + ' ' +\
2006            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
2007            'healthy: ' + repr(self.healthy) + ' ' +\
2008            'id: ' + repr(self.id) + ' ' +\
2009            'name: ' + repr(self.name) + ' ' +\
2010            'region: ' + repr(self.region) + ' ' +\
2011            'role_arn: ' + repr(self.role_arn) + ' ' +\
2012            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2013            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2014            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2015            'tags: ' + repr(self.tags) + ' ' +\
2016            '>'
2017
2018    def to_dict(self):
2019        return {
2020            'access_key': self.access_key,
2021            'bind_interface': self.bind_interface,
2022            'certificate_authority': self.certificate_authority,
2023            'cluster_name': self.cluster_name,
2024            'egress_filter': self.egress_filter,
2025            'endpoint': self.endpoint,
2026            'healthcheck_namespace': self.healthcheck_namespace,
2027            'healthy': self.healthy,
2028            'id': self.id,
2029            'name': self.name,
2030            'region': self.region,
2031            'role_arn': self.role_arn,
2032            'role_external_id': self.role_external_id,
2033            'secret_access_key': self.secret_access_key,
2034            'secret_store_id': self.secret_store_id,
2035            'tags': self.tags,
2036        }
2037
2038    @classmethod
2039    def from_dict(cls, d):
2040        return cls(
2041            access_key=d.get('access_key'),
2042            bind_interface=d.get('bind_interface'),
2043            certificate_authority=d.get('certificate_authority'),
2044            cluster_name=d.get('cluster_name'),
2045            egress_filter=d.get('egress_filter'),
2046            endpoint=d.get('endpoint'),
2047            healthcheck_namespace=d.get('healthcheck_namespace'),
2048            healthy=d.get('healthy'),
2049            id=d.get('id'),
2050            name=d.get('name'),
2051            region=d.get('region'),
2052            role_arn=d.get('role_arn'),
2053            role_external_id=d.get('role_external_id'),
2054            secret_access_key=d.get('secret_access_key'),
2055            secret_store_id=d.get('secret_store_id'),
2056            tags=d.get('tags'),
2057        )
AmazonEKSUserImpersonation( access_key=None, bind_interface=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1938    def __init__(
1939        self,
1940        access_key=None,
1941        bind_interface=None,
1942        certificate_authority=None,
1943        cluster_name=None,
1944        egress_filter=None,
1945        endpoint=None,
1946        healthcheck_namespace=None,
1947        healthy=None,
1948        id=None,
1949        name=None,
1950        region=None,
1951        role_arn=None,
1952        role_external_id=None,
1953        secret_access_key=None,
1954        secret_store_id=None,
1955        tags=None,
1956    ):
1957        self.access_key = access_key if access_key is not None else ''
1958        self.bind_interface = bind_interface if bind_interface is not None else ''
1959        '''
1960         Bind interface
1961        '''
1962        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1963        self.cluster_name = cluster_name if cluster_name is not None else ''
1964        self.egress_filter = egress_filter if egress_filter is not None else ''
1965        '''
1966         A filter applied to the routing logic to pin datasource to nodes.
1967        '''
1968        self.endpoint = endpoint if endpoint is not None else ''
1969        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1970        '''
1971         The path used to check the health of your connection.  Defaults to `default`.
1972        '''
1973        self.healthy = healthy if healthy is not None else False
1974        '''
1975         True if the datasource is reachable and the credentials are valid.
1976        '''
1977        self.id = id if id is not None else ''
1978        '''
1979         Unique identifier of the Resource.
1980        '''
1981        self.name = name if name is not None else ''
1982        '''
1983         Unique human-readable name of the Resource.
1984        '''
1985        self.region = region if region is not None else ''
1986        self.role_arn = role_arn if role_arn is not None else ''
1987        self.role_external_id = role_external_id if role_external_id is not None else ''
1988        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1989        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1990        '''
1991         ID of the secret store containing credentials for this resource, if any.
1992        '''
1993        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1994        '''
1995         Tags is a map of key, value pairs.
1996        '''
access_key
bind_interface

Bind interface

certificate_authority
cluster_name
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2018    def to_dict(self):
2019        return {
2020            'access_key': self.access_key,
2021            'bind_interface': self.bind_interface,
2022            'certificate_authority': self.certificate_authority,
2023            'cluster_name': self.cluster_name,
2024            'egress_filter': self.egress_filter,
2025            'endpoint': self.endpoint,
2026            'healthcheck_namespace': self.healthcheck_namespace,
2027            'healthy': self.healthy,
2028            'id': self.id,
2029            'name': self.name,
2030            'region': self.region,
2031            'role_arn': self.role_arn,
2032            'role_external_id': self.role_external_id,
2033            'secret_access_key': self.secret_access_key,
2034            'secret_store_id': self.secret_store_id,
2035            'tags': self.tags,
2036        }
@classmethod
def from_dict(cls, d)
2038    @classmethod
2039    def from_dict(cls, d):
2040        return cls(
2041            access_key=d.get('access_key'),
2042            bind_interface=d.get('bind_interface'),
2043            certificate_authority=d.get('certificate_authority'),
2044            cluster_name=d.get('cluster_name'),
2045            egress_filter=d.get('egress_filter'),
2046            endpoint=d.get('endpoint'),
2047            healthcheck_namespace=d.get('healthcheck_namespace'),
2048            healthy=d.get('healthy'),
2049            id=d.get('id'),
2050            name=d.get('name'),
2051            region=d.get('region'),
2052            role_arn=d.get('role_arn'),
2053            role_external_id=d.get('role_external_id'),
2054            secret_access_key=d.get('secret_access_key'),
2055            secret_store_id=d.get('secret_store_id'),
2056            tags=d.get('tags'),
2057        )
class AmazonES:
2060class AmazonES:
2061    __slots__ = [
2062        'access_key',
2063        'bind_interface',
2064        'egress_filter',
2065        'endpoint',
2066        'healthy',
2067        'id',
2068        'name',
2069        'port_override',
2070        'region',
2071        'role_arn',
2072        'role_external_id',
2073        'secret_access_key',
2074        'secret_store_id',
2075        'tags',
2076    ]
2077
2078    def __init__(
2079        self,
2080        access_key=None,
2081        bind_interface=None,
2082        egress_filter=None,
2083        endpoint=None,
2084        healthy=None,
2085        id=None,
2086        name=None,
2087        port_override=None,
2088        region=None,
2089        role_arn=None,
2090        role_external_id=None,
2091        secret_access_key=None,
2092        secret_store_id=None,
2093        tags=None,
2094    ):
2095        self.access_key = access_key if access_key is not None else ''
2096        self.bind_interface = bind_interface if bind_interface is not None else ''
2097        '''
2098         Bind interface
2099        '''
2100        self.egress_filter = egress_filter if egress_filter is not None else ''
2101        '''
2102         A filter applied to the routing logic to pin datasource to nodes.
2103        '''
2104        self.endpoint = endpoint if endpoint is not None else ''
2105        self.healthy = healthy if healthy is not None else False
2106        '''
2107         True if the datasource is reachable and the credentials are valid.
2108        '''
2109        self.id = id if id is not None else ''
2110        '''
2111         Unique identifier of the Resource.
2112        '''
2113        self.name = name if name is not None else ''
2114        '''
2115         Unique human-readable name of the Resource.
2116        '''
2117        self.port_override = port_override if port_override is not None else 0
2118        self.region = region if region is not None else ''
2119        self.role_arn = role_arn if role_arn is not None else ''
2120        self.role_external_id = role_external_id if role_external_id is not None else ''
2121        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2122        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2123        '''
2124         ID of the secret store containing credentials for this resource, if any.
2125        '''
2126        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2127        '''
2128         Tags is a map of key, value pairs.
2129        '''
2130
2131    def __repr__(self):
2132        return '<sdm.AmazonES ' + \
2133            'access_key: ' + repr(self.access_key) + ' ' +\
2134            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2135            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2136            'endpoint: ' + repr(self.endpoint) + ' ' +\
2137            'healthy: ' + repr(self.healthy) + ' ' +\
2138            'id: ' + repr(self.id) + ' ' +\
2139            'name: ' + repr(self.name) + ' ' +\
2140            'port_override: ' + repr(self.port_override) + ' ' +\
2141            'region: ' + repr(self.region) + ' ' +\
2142            'role_arn: ' + repr(self.role_arn) + ' ' +\
2143            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2144            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2145            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2146            'tags: ' + repr(self.tags) + ' ' +\
2147            '>'
2148
2149    def to_dict(self):
2150        return {
2151            'access_key': self.access_key,
2152            'bind_interface': self.bind_interface,
2153            'egress_filter': self.egress_filter,
2154            'endpoint': self.endpoint,
2155            'healthy': self.healthy,
2156            'id': self.id,
2157            'name': self.name,
2158            'port_override': self.port_override,
2159            'region': self.region,
2160            'role_arn': self.role_arn,
2161            'role_external_id': self.role_external_id,
2162            'secret_access_key': self.secret_access_key,
2163            'secret_store_id': self.secret_store_id,
2164            'tags': self.tags,
2165        }
2166
2167    @classmethod
2168    def from_dict(cls, d):
2169        return cls(
2170            access_key=d.get('access_key'),
2171            bind_interface=d.get('bind_interface'),
2172            egress_filter=d.get('egress_filter'),
2173            endpoint=d.get('endpoint'),
2174            healthy=d.get('healthy'),
2175            id=d.get('id'),
2176            name=d.get('name'),
2177            port_override=d.get('port_override'),
2178            region=d.get('region'),
2179            role_arn=d.get('role_arn'),
2180            role_external_id=d.get('role_external_id'),
2181            secret_access_key=d.get('secret_access_key'),
2182            secret_store_id=d.get('secret_store_id'),
2183            tags=d.get('tags'),
2184        )
AmazonES( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
2078    def __init__(
2079        self,
2080        access_key=None,
2081        bind_interface=None,
2082        egress_filter=None,
2083        endpoint=None,
2084        healthy=None,
2085        id=None,
2086        name=None,
2087        port_override=None,
2088        region=None,
2089        role_arn=None,
2090        role_external_id=None,
2091        secret_access_key=None,
2092        secret_store_id=None,
2093        tags=None,
2094    ):
2095        self.access_key = access_key if access_key is not None else ''
2096        self.bind_interface = bind_interface if bind_interface is not None else ''
2097        '''
2098         Bind interface
2099        '''
2100        self.egress_filter = egress_filter if egress_filter is not None else ''
2101        '''
2102         A filter applied to the routing logic to pin datasource to nodes.
2103        '''
2104        self.endpoint = endpoint if endpoint is not None else ''
2105        self.healthy = healthy if healthy is not None else False
2106        '''
2107         True if the datasource is reachable and the credentials are valid.
2108        '''
2109        self.id = id if id is not None else ''
2110        '''
2111         Unique identifier of the Resource.
2112        '''
2113        self.name = name if name is not None else ''
2114        '''
2115         Unique human-readable name of the Resource.
2116        '''
2117        self.port_override = port_override if port_override is not None else 0
2118        self.region = region if region is not None else ''
2119        self.role_arn = role_arn if role_arn is not None else ''
2120        self.role_external_id = role_external_id if role_external_id is not None else ''
2121        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2122        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2123        '''
2124         ID of the secret store containing credentials for this resource, if any.
2125        '''
2126        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2127        '''
2128         Tags is a map of key, value pairs.
2129        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2149    def to_dict(self):
2150        return {
2151            'access_key': self.access_key,
2152            'bind_interface': self.bind_interface,
2153            'egress_filter': self.egress_filter,
2154            'endpoint': self.endpoint,
2155            'healthy': self.healthy,
2156            'id': self.id,
2157            'name': self.name,
2158            'port_override': self.port_override,
2159            'region': self.region,
2160            'role_arn': self.role_arn,
2161            'role_external_id': self.role_external_id,
2162            'secret_access_key': self.secret_access_key,
2163            'secret_store_id': self.secret_store_id,
2164            'tags': self.tags,
2165        }
@classmethod
def from_dict(cls, d)
2167    @classmethod
2168    def from_dict(cls, d):
2169        return cls(
2170            access_key=d.get('access_key'),
2171            bind_interface=d.get('bind_interface'),
2172            egress_filter=d.get('egress_filter'),
2173            endpoint=d.get('endpoint'),
2174            healthy=d.get('healthy'),
2175            id=d.get('id'),
2176            name=d.get('name'),
2177            port_override=d.get('port_override'),
2178            region=d.get('region'),
2179            role_arn=d.get('role_arn'),
2180            role_external_id=d.get('role_external_id'),
2181            secret_access_key=d.get('secret_access_key'),
2182            secret_store_id=d.get('secret_store_id'),
2183            tags=d.get('tags'),
2184        )
class AmazonMQAMQP091:
2187class AmazonMQAMQP091:
2188    __slots__ = [
2189        'bind_interface',
2190        'egress_filter',
2191        'healthy',
2192        'hostname',
2193        'id',
2194        'name',
2195        'password',
2196        'port',
2197        'port_override',
2198        'secret_store_id',
2199        'tags',
2200        'tls_required',
2201        'username',
2202    ]
2203
2204    def __init__(
2205        self,
2206        bind_interface=None,
2207        egress_filter=None,
2208        healthy=None,
2209        hostname=None,
2210        id=None,
2211        name=None,
2212        password=None,
2213        port=None,
2214        port_override=None,
2215        secret_store_id=None,
2216        tags=None,
2217        tls_required=None,
2218        username=None,
2219    ):
2220        self.bind_interface = bind_interface if bind_interface is not None else ''
2221        '''
2222         Bind interface
2223        '''
2224        self.egress_filter = egress_filter if egress_filter is not None else ''
2225        '''
2226         A filter applied to the routing logic to pin datasource to nodes.
2227        '''
2228        self.healthy = healthy if healthy is not None else False
2229        '''
2230         True if the datasource is reachable and the credentials are valid.
2231        '''
2232        self.hostname = hostname if hostname is not None else ''
2233        self.id = id if id is not None else ''
2234        '''
2235         Unique identifier of the Resource.
2236        '''
2237        self.name = name if name is not None else ''
2238        '''
2239         Unique human-readable name of the Resource.
2240        '''
2241        self.password = password if password is not None else ''
2242        self.port = port if port is not None else 0
2243        self.port_override = port_override if port_override is not None else 0
2244        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2245        '''
2246         ID of the secret store containing credentials for this resource, if any.
2247        '''
2248        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2249        '''
2250         Tags is a map of key, value pairs.
2251        '''
2252        self.tls_required = tls_required if tls_required is not None else False
2253        self.username = username if username is not None else ''
2254
2255    def __repr__(self):
2256        return '<sdm.AmazonMQAMQP091 ' + \
2257            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2258            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2259            'healthy: ' + repr(self.healthy) + ' ' +\
2260            'hostname: ' + repr(self.hostname) + ' ' +\
2261            'id: ' + repr(self.id) + ' ' +\
2262            'name: ' + repr(self.name) + ' ' +\
2263            'password: ' + repr(self.password) + ' ' +\
2264            'port: ' + repr(self.port) + ' ' +\
2265            'port_override: ' + repr(self.port_override) + ' ' +\
2266            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2267            'tags: ' + repr(self.tags) + ' ' +\
2268            'tls_required: ' + repr(self.tls_required) + ' ' +\
2269            'username: ' + repr(self.username) + ' ' +\
2270            '>'
2271
2272    def to_dict(self):
2273        return {
2274            'bind_interface': self.bind_interface,
2275            'egress_filter': self.egress_filter,
2276            'healthy': self.healthy,
2277            'hostname': self.hostname,
2278            'id': self.id,
2279            'name': self.name,
2280            'password': self.password,
2281            'port': self.port,
2282            'port_override': self.port_override,
2283            'secret_store_id': self.secret_store_id,
2284            'tags': self.tags,
2285            'tls_required': self.tls_required,
2286            'username': self.username,
2287        }
2288
2289    @classmethod
2290    def from_dict(cls, d):
2291        return cls(
2292            bind_interface=d.get('bind_interface'),
2293            egress_filter=d.get('egress_filter'),
2294            healthy=d.get('healthy'),
2295            hostname=d.get('hostname'),
2296            id=d.get('id'),
2297            name=d.get('name'),
2298            password=d.get('password'),
2299            port=d.get('port'),
2300            port_override=d.get('port_override'),
2301            secret_store_id=d.get('secret_store_id'),
2302            tags=d.get('tags'),
2303            tls_required=d.get('tls_required'),
2304            username=d.get('username'),
2305        )
AmazonMQAMQP091( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
2204    def __init__(
2205        self,
2206        bind_interface=None,
2207        egress_filter=None,
2208        healthy=None,
2209        hostname=None,
2210        id=None,
2211        name=None,
2212        password=None,
2213        port=None,
2214        port_override=None,
2215        secret_store_id=None,
2216        tags=None,
2217        tls_required=None,
2218        username=None,
2219    ):
2220        self.bind_interface = bind_interface if bind_interface is not None else ''
2221        '''
2222         Bind interface
2223        '''
2224        self.egress_filter = egress_filter if egress_filter is not None else ''
2225        '''
2226         A filter applied to the routing logic to pin datasource to nodes.
2227        '''
2228        self.healthy = healthy if healthy is not None else False
2229        '''
2230         True if the datasource is reachable and the credentials are valid.
2231        '''
2232        self.hostname = hostname if hostname is not None else ''
2233        self.id = id if id is not None else ''
2234        '''
2235         Unique identifier of the Resource.
2236        '''
2237        self.name = name if name is not None else ''
2238        '''
2239         Unique human-readable name of the Resource.
2240        '''
2241        self.password = password if password is not None else ''
2242        self.port = port if port is not None else 0
2243        self.port_override = port_override if port_override is not None else 0
2244        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2245        '''
2246         ID of the secret store containing credentials for this resource, if any.
2247        '''
2248        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2249        '''
2250         Tags is a map of key, value pairs.
2251        '''
2252        self.tls_required = tls_required if tls_required is not None else False
2253        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
2272    def to_dict(self):
2273        return {
2274            'bind_interface': self.bind_interface,
2275            'egress_filter': self.egress_filter,
2276            'healthy': self.healthy,
2277            'hostname': self.hostname,
2278            'id': self.id,
2279            'name': self.name,
2280            'password': self.password,
2281            'port': self.port,
2282            'port_override': self.port_override,
2283            'secret_store_id': self.secret_store_id,
2284            'tags': self.tags,
2285            'tls_required': self.tls_required,
2286            'username': self.username,
2287        }
@classmethod
def from_dict(cls, d)
2289    @classmethod
2290    def from_dict(cls, d):
2291        return cls(
2292            bind_interface=d.get('bind_interface'),
2293            egress_filter=d.get('egress_filter'),
2294            healthy=d.get('healthy'),
2295            hostname=d.get('hostname'),
2296            id=d.get('id'),
2297            name=d.get('name'),
2298            password=d.get('password'),
2299            port=d.get('port'),
2300            port_override=d.get('port_override'),
2301            secret_store_id=d.get('secret_store_id'),
2302            tags=d.get('tags'),
2303            tls_required=d.get('tls_required'),
2304            username=d.get('username'),
2305        )
class Athena:
2308class Athena:
2309    __slots__ = [
2310        'access_key',
2311        'bind_interface',
2312        'egress_filter',
2313        'healthy',
2314        'id',
2315        'name',
2316        'output',
2317        'port_override',
2318        'region',
2319        'role_arn',
2320        'role_external_id',
2321        'secret_access_key',
2322        'secret_store_id',
2323        'tags',
2324    ]
2325
2326    def __init__(
2327        self,
2328        access_key=None,
2329        bind_interface=None,
2330        egress_filter=None,
2331        healthy=None,
2332        id=None,
2333        name=None,
2334        output=None,
2335        port_override=None,
2336        region=None,
2337        role_arn=None,
2338        role_external_id=None,
2339        secret_access_key=None,
2340        secret_store_id=None,
2341        tags=None,
2342    ):
2343        self.access_key = access_key if access_key is not None else ''
2344        self.bind_interface = bind_interface if bind_interface is not None else ''
2345        '''
2346         Bind interface
2347        '''
2348        self.egress_filter = egress_filter if egress_filter is not None else ''
2349        '''
2350         A filter applied to the routing logic to pin datasource to nodes.
2351        '''
2352        self.healthy = healthy if healthy is not None else False
2353        '''
2354         True if the datasource is reachable and the credentials are valid.
2355        '''
2356        self.id = id if id is not None else ''
2357        '''
2358         Unique identifier of the Resource.
2359        '''
2360        self.name = name if name is not None else ''
2361        '''
2362         Unique human-readable name of the Resource.
2363        '''
2364        self.output = output if output is not None else ''
2365        self.port_override = port_override if port_override is not None else 0
2366        self.region = region if region is not None else ''
2367        self.role_arn = role_arn if role_arn is not None else ''
2368        self.role_external_id = role_external_id if role_external_id is not None else ''
2369        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2370        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2371        '''
2372         ID of the secret store containing credentials for this resource, if any.
2373        '''
2374        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2375        '''
2376         Tags is a map of key, value pairs.
2377        '''
2378
2379    def __repr__(self):
2380        return '<sdm.Athena ' + \
2381            'access_key: ' + repr(self.access_key) + ' ' +\
2382            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2383            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2384            'healthy: ' + repr(self.healthy) + ' ' +\
2385            'id: ' + repr(self.id) + ' ' +\
2386            'name: ' + repr(self.name) + ' ' +\
2387            'output: ' + repr(self.output) + ' ' +\
2388            'port_override: ' + repr(self.port_override) + ' ' +\
2389            'region: ' + repr(self.region) + ' ' +\
2390            'role_arn: ' + repr(self.role_arn) + ' ' +\
2391            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2392            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2393            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2394            'tags: ' + repr(self.tags) + ' ' +\
2395            '>'
2396
2397    def to_dict(self):
2398        return {
2399            'access_key': self.access_key,
2400            'bind_interface': self.bind_interface,
2401            'egress_filter': self.egress_filter,
2402            'healthy': self.healthy,
2403            'id': self.id,
2404            'name': self.name,
2405            'output': self.output,
2406            'port_override': self.port_override,
2407            'region': self.region,
2408            'role_arn': self.role_arn,
2409            'role_external_id': self.role_external_id,
2410            'secret_access_key': self.secret_access_key,
2411            'secret_store_id': self.secret_store_id,
2412            'tags': self.tags,
2413        }
2414
2415    @classmethod
2416    def from_dict(cls, d):
2417        return cls(
2418            access_key=d.get('access_key'),
2419            bind_interface=d.get('bind_interface'),
2420            egress_filter=d.get('egress_filter'),
2421            healthy=d.get('healthy'),
2422            id=d.get('id'),
2423            name=d.get('name'),
2424            output=d.get('output'),
2425            port_override=d.get('port_override'),
2426            region=d.get('region'),
2427            role_arn=d.get('role_arn'),
2428            role_external_id=d.get('role_external_id'),
2429            secret_access_key=d.get('secret_access_key'),
2430            secret_store_id=d.get('secret_store_id'),
2431            tags=d.get('tags'),
2432        )
Athena( access_key=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, output=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
2326    def __init__(
2327        self,
2328        access_key=None,
2329        bind_interface=None,
2330        egress_filter=None,
2331        healthy=None,
2332        id=None,
2333        name=None,
2334        output=None,
2335        port_override=None,
2336        region=None,
2337        role_arn=None,
2338        role_external_id=None,
2339        secret_access_key=None,
2340        secret_store_id=None,
2341        tags=None,
2342    ):
2343        self.access_key = access_key if access_key is not None else ''
2344        self.bind_interface = bind_interface if bind_interface is not None else ''
2345        '''
2346         Bind interface
2347        '''
2348        self.egress_filter = egress_filter if egress_filter is not None else ''
2349        '''
2350         A filter applied to the routing logic to pin datasource to nodes.
2351        '''
2352        self.healthy = healthy if healthy is not None else False
2353        '''
2354         True if the datasource is reachable and the credentials are valid.
2355        '''
2356        self.id = id if id is not None else ''
2357        '''
2358         Unique identifier of the Resource.
2359        '''
2360        self.name = name if name is not None else ''
2361        '''
2362         Unique human-readable name of the Resource.
2363        '''
2364        self.output = output if output is not None else ''
2365        self.port_override = port_override if port_override is not None else 0
2366        self.region = region if region is not None else ''
2367        self.role_arn = role_arn if role_arn is not None else ''
2368        self.role_external_id = role_external_id if role_external_id is not None else ''
2369        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2370        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2371        '''
2372         ID of the secret store containing credentials for this resource, if any.
2373        '''
2374        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2375        '''
2376         Tags is a map of key, value pairs.
2377        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

output
port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2397    def to_dict(self):
2398        return {
2399            'access_key': self.access_key,
2400            'bind_interface': self.bind_interface,
2401            'egress_filter': self.egress_filter,
2402            'healthy': self.healthy,
2403            'id': self.id,
2404            'name': self.name,
2405            'output': self.output,
2406            'port_override': self.port_override,
2407            'region': self.region,
2408            'role_arn': self.role_arn,
2409            'role_external_id': self.role_external_id,
2410            'secret_access_key': self.secret_access_key,
2411            'secret_store_id': self.secret_store_id,
2412            'tags': self.tags,
2413        }
@classmethod
def from_dict(cls, d)
2415    @classmethod
2416    def from_dict(cls, d):
2417        return cls(
2418            access_key=d.get('access_key'),
2419            bind_interface=d.get('bind_interface'),
2420            egress_filter=d.get('egress_filter'),
2421            healthy=d.get('healthy'),
2422            id=d.get('id'),
2423            name=d.get('name'),
2424            output=d.get('output'),
2425            port_override=d.get('port_override'),
2426            region=d.get('region'),
2427            role_arn=d.get('role_arn'),
2428            role_external_id=d.get('role_external_id'),
2429            secret_access_key=d.get('secret_access_key'),
2430            secret_store_id=d.get('secret_store_id'),
2431            tags=d.get('tags'),
2432        )
class AuroraMysql:
2435class AuroraMysql:
2436    __slots__ = [
2437        'bind_interface',
2438        'database',
2439        'egress_filter',
2440        'healthy',
2441        'hostname',
2442        'id',
2443        'name',
2444        'password',
2445        'port',
2446        'port_override',
2447        'secret_store_id',
2448        'tags',
2449        'username',
2450    ]
2451
2452    def __init__(
2453        self,
2454        bind_interface=None,
2455        database=None,
2456        egress_filter=None,
2457        healthy=None,
2458        hostname=None,
2459        id=None,
2460        name=None,
2461        password=None,
2462        port=None,
2463        port_override=None,
2464        secret_store_id=None,
2465        tags=None,
2466        username=None,
2467    ):
2468        self.bind_interface = bind_interface if bind_interface is not None else ''
2469        '''
2470         Bind interface
2471        '''
2472        self.database = database if database is not None else ''
2473        self.egress_filter = egress_filter if egress_filter is not None else ''
2474        '''
2475         A filter applied to the routing logic to pin datasource to nodes.
2476        '''
2477        self.healthy = healthy if healthy is not None else False
2478        '''
2479         True if the datasource is reachable and the credentials are valid.
2480        '''
2481        self.hostname = hostname if hostname is not None else ''
2482        self.id = id if id is not None else ''
2483        '''
2484         Unique identifier of the Resource.
2485        '''
2486        self.name = name if name is not None else ''
2487        '''
2488         Unique human-readable name of the Resource.
2489        '''
2490        self.password = password if password is not None else ''
2491        self.port = port if port is not None else 0
2492        self.port_override = port_override if port_override is not None else 0
2493        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2494        '''
2495         ID of the secret store containing credentials for this resource, if any.
2496        '''
2497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2498        '''
2499         Tags is a map of key, value pairs.
2500        '''
2501        self.username = username if username is not None else ''
2502
2503    def __repr__(self):
2504        return '<sdm.AuroraMysql ' + \
2505            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2506            'database: ' + repr(self.database) + ' ' +\
2507            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2508            'healthy: ' + repr(self.healthy) + ' ' +\
2509            'hostname: ' + repr(self.hostname) + ' ' +\
2510            'id: ' + repr(self.id) + ' ' +\
2511            'name: ' + repr(self.name) + ' ' +\
2512            'password: ' + repr(self.password) + ' ' +\
2513            'port: ' + repr(self.port) + ' ' +\
2514            'port_override: ' + repr(self.port_override) + ' ' +\
2515            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2516            'tags: ' + repr(self.tags) + ' ' +\
2517            'username: ' + repr(self.username) + ' ' +\
2518            '>'
2519
2520    def to_dict(self):
2521        return {
2522            'bind_interface': self.bind_interface,
2523            'database': self.database,
2524            'egress_filter': self.egress_filter,
2525            'healthy': self.healthy,
2526            'hostname': self.hostname,
2527            'id': self.id,
2528            'name': self.name,
2529            'password': self.password,
2530            'port': self.port,
2531            'port_override': self.port_override,
2532            'secret_store_id': self.secret_store_id,
2533            'tags': self.tags,
2534            'username': self.username,
2535        }
2536
2537    @classmethod
2538    def from_dict(cls, d):
2539        return cls(
2540            bind_interface=d.get('bind_interface'),
2541            database=d.get('database'),
2542            egress_filter=d.get('egress_filter'),
2543            healthy=d.get('healthy'),
2544            hostname=d.get('hostname'),
2545            id=d.get('id'),
2546            name=d.get('name'),
2547            password=d.get('password'),
2548            port=d.get('port'),
2549            port_override=d.get('port_override'),
2550            secret_store_id=d.get('secret_store_id'),
2551            tags=d.get('tags'),
2552            username=d.get('username'),
2553        )
AuroraMysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2452    def __init__(
2453        self,
2454        bind_interface=None,
2455        database=None,
2456        egress_filter=None,
2457        healthy=None,
2458        hostname=None,
2459        id=None,
2460        name=None,
2461        password=None,
2462        port=None,
2463        port_override=None,
2464        secret_store_id=None,
2465        tags=None,
2466        username=None,
2467    ):
2468        self.bind_interface = bind_interface if bind_interface is not None else ''
2469        '''
2470         Bind interface
2471        '''
2472        self.database = database if database is not None else ''
2473        self.egress_filter = egress_filter if egress_filter is not None else ''
2474        '''
2475         A filter applied to the routing logic to pin datasource to nodes.
2476        '''
2477        self.healthy = healthy if healthy is not None else False
2478        '''
2479         True if the datasource is reachable and the credentials are valid.
2480        '''
2481        self.hostname = hostname if hostname is not None else ''
2482        self.id = id if id is not None else ''
2483        '''
2484         Unique identifier of the Resource.
2485        '''
2486        self.name = name if name is not None else ''
2487        '''
2488         Unique human-readable name of the Resource.
2489        '''
2490        self.password = password if password is not None else ''
2491        self.port = port if port is not None else 0
2492        self.port_override = port_override if port_override is not None else 0
2493        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2494        '''
2495         ID of the secret store containing credentials for this resource, if any.
2496        '''
2497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2498        '''
2499         Tags is a map of key, value pairs.
2500        '''
2501        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2520    def to_dict(self):
2521        return {
2522            'bind_interface': self.bind_interface,
2523            'database': self.database,
2524            'egress_filter': self.egress_filter,
2525            'healthy': self.healthy,
2526            'hostname': self.hostname,
2527            'id': self.id,
2528            'name': self.name,
2529            'password': self.password,
2530            'port': self.port,
2531            'port_override': self.port_override,
2532            'secret_store_id': self.secret_store_id,
2533            'tags': self.tags,
2534            'username': self.username,
2535        }
@classmethod
def from_dict(cls, d)
2537    @classmethod
2538    def from_dict(cls, d):
2539        return cls(
2540            bind_interface=d.get('bind_interface'),
2541            database=d.get('database'),
2542            egress_filter=d.get('egress_filter'),
2543            healthy=d.get('healthy'),
2544            hostname=d.get('hostname'),
2545            id=d.get('id'),
2546            name=d.get('name'),
2547            password=d.get('password'),
2548            port=d.get('port'),
2549            port_override=d.get('port_override'),
2550            secret_store_id=d.get('secret_store_id'),
2551            tags=d.get('tags'),
2552            username=d.get('username'),
2553        )
class AuroraPostgres:
2556class AuroraPostgres:
2557    __slots__ = [
2558        'bind_interface',
2559        'database',
2560        'egress_filter',
2561        'healthy',
2562        'hostname',
2563        'id',
2564        'name',
2565        'override_database',
2566        'password',
2567        'port',
2568        'port_override',
2569        'secret_store_id',
2570        'tags',
2571        'username',
2572    ]
2573
2574    def __init__(
2575        self,
2576        bind_interface=None,
2577        database=None,
2578        egress_filter=None,
2579        healthy=None,
2580        hostname=None,
2581        id=None,
2582        name=None,
2583        override_database=None,
2584        password=None,
2585        port=None,
2586        port_override=None,
2587        secret_store_id=None,
2588        tags=None,
2589        username=None,
2590    ):
2591        self.bind_interface = bind_interface if bind_interface is not None else ''
2592        '''
2593         Bind interface
2594        '''
2595        self.database = database if database is not None else ''
2596        self.egress_filter = egress_filter if egress_filter is not None else ''
2597        '''
2598         A filter applied to the routing logic to pin datasource to nodes.
2599        '''
2600        self.healthy = healthy if healthy is not None else False
2601        '''
2602         True if the datasource is reachable and the credentials are valid.
2603        '''
2604        self.hostname = hostname if hostname is not None else ''
2605        self.id = id if id is not None else ''
2606        '''
2607         Unique identifier of the Resource.
2608        '''
2609        self.name = name if name is not None else ''
2610        '''
2611         Unique human-readable name of the Resource.
2612        '''
2613        self.override_database = override_database if override_database is not None else False
2614        self.password = password if password is not None else ''
2615        self.port = port if port is not None else 0
2616        self.port_override = port_override if port_override is not None else 0
2617        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2618        '''
2619         ID of the secret store containing credentials for this resource, if any.
2620        '''
2621        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2622        '''
2623         Tags is a map of key, value pairs.
2624        '''
2625        self.username = username if username is not None else ''
2626
2627    def __repr__(self):
2628        return '<sdm.AuroraPostgres ' + \
2629            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2630            'database: ' + repr(self.database) + ' ' +\
2631            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2632            'healthy: ' + repr(self.healthy) + ' ' +\
2633            'hostname: ' + repr(self.hostname) + ' ' +\
2634            'id: ' + repr(self.id) + ' ' +\
2635            'name: ' + repr(self.name) + ' ' +\
2636            'override_database: ' + repr(self.override_database) + ' ' +\
2637            'password: ' + repr(self.password) + ' ' +\
2638            'port: ' + repr(self.port) + ' ' +\
2639            'port_override: ' + repr(self.port_override) + ' ' +\
2640            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2641            'tags: ' + repr(self.tags) + ' ' +\
2642            'username: ' + repr(self.username) + ' ' +\
2643            '>'
2644
2645    def to_dict(self):
2646        return {
2647            'bind_interface': self.bind_interface,
2648            'database': self.database,
2649            'egress_filter': self.egress_filter,
2650            'healthy': self.healthy,
2651            'hostname': self.hostname,
2652            'id': self.id,
2653            'name': self.name,
2654            'override_database': self.override_database,
2655            'password': self.password,
2656            'port': self.port,
2657            'port_override': self.port_override,
2658            'secret_store_id': self.secret_store_id,
2659            'tags': self.tags,
2660            'username': self.username,
2661        }
2662
2663    @classmethod
2664    def from_dict(cls, d):
2665        return cls(
2666            bind_interface=d.get('bind_interface'),
2667            database=d.get('database'),
2668            egress_filter=d.get('egress_filter'),
2669            healthy=d.get('healthy'),
2670            hostname=d.get('hostname'),
2671            id=d.get('id'),
2672            name=d.get('name'),
2673            override_database=d.get('override_database'),
2674            password=d.get('password'),
2675            port=d.get('port'),
2676            port_override=d.get('port_override'),
2677            secret_store_id=d.get('secret_store_id'),
2678            tags=d.get('tags'),
2679            username=d.get('username'),
2680        )
AuroraPostgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2574    def __init__(
2575        self,
2576        bind_interface=None,
2577        database=None,
2578        egress_filter=None,
2579        healthy=None,
2580        hostname=None,
2581        id=None,
2582        name=None,
2583        override_database=None,
2584        password=None,
2585        port=None,
2586        port_override=None,
2587        secret_store_id=None,
2588        tags=None,
2589        username=None,
2590    ):
2591        self.bind_interface = bind_interface if bind_interface is not None else ''
2592        '''
2593         Bind interface
2594        '''
2595        self.database = database if database is not None else ''
2596        self.egress_filter = egress_filter if egress_filter is not None else ''
2597        '''
2598         A filter applied to the routing logic to pin datasource to nodes.
2599        '''
2600        self.healthy = healthy if healthy is not None else False
2601        '''
2602         True if the datasource is reachable and the credentials are valid.
2603        '''
2604        self.hostname = hostname if hostname is not None else ''
2605        self.id = id if id is not None else ''
2606        '''
2607         Unique identifier of the Resource.
2608        '''
2609        self.name = name if name is not None else ''
2610        '''
2611         Unique human-readable name of the Resource.
2612        '''
2613        self.override_database = override_database if override_database is not None else False
2614        self.password = password if password is not None else ''
2615        self.port = port if port is not None else 0
2616        self.port_override = port_override if port_override is not None else 0
2617        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2618        '''
2619         ID of the secret store containing credentials for this resource, if any.
2620        '''
2621        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2622        '''
2623         Tags is a map of key, value pairs.
2624        '''
2625        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2645    def to_dict(self):
2646        return {
2647            'bind_interface': self.bind_interface,
2648            'database': self.database,
2649            'egress_filter': self.egress_filter,
2650            'healthy': self.healthy,
2651            'hostname': self.hostname,
2652            'id': self.id,
2653            'name': self.name,
2654            'override_database': self.override_database,
2655            'password': self.password,
2656            'port': self.port,
2657            'port_override': self.port_override,
2658            'secret_store_id': self.secret_store_id,
2659            'tags': self.tags,
2660            'username': self.username,
2661        }
@classmethod
def from_dict(cls, d)
2663    @classmethod
2664    def from_dict(cls, d):
2665        return cls(
2666            bind_interface=d.get('bind_interface'),
2667            database=d.get('database'),
2668            egress_filter=d.get('egress_filter'),
2669            healthy=d.get('healthy'),
2670            hostname=d.get('hostname'),
2671            id=d.get('id'),
2672            name=d.get('name'),
2673            override_database=d.get('override_database'),
2674            password=d.get('password'),
2675            port=d.get('port'),
2676            port_override=d.get('port_override'),
2677            secret_store_id=d.get('secret_store_id'),
2678            tags=d.get('tags'),
2679            username=d.get('username'),
2680        )
class Azure:
2683class Azure:
2684    __slots__ = [
2685        'app_id',
2686        'bind_interface',
2687        'egress_filter',
2688        'healthy',
2689        'id',
2690        'name',
2691        'password',
2692        'secret_store_id',
2693        'tags',
2694        'tenant_id',
2695    ]
2696
2697    def __init__(
2698        self,
2699        app_id=None,
2700        bind_interface=None,
2701        egress_filter=None,
2702        healthy=None,
2703        id=None,
2704        name=None,
2705        password=None,
2706        secret_store_id=None,
2707        tags=None,
2708        tenant_id=None,
2709    ):
2710        self.app_id = app_id if app_id is not None else ''
2711        self.bind_interface = bind_interface if bind_interface is not None else ''
2712        '''
2713         Bind interface
2714        '''
2715        self.egress_filter = egress_filter if egress_filter is not None else ''
2716        '''
2717         A filter applied to the routing logic to pin datasource to nodes.
2718        '''
2719        self.healthy = healthy if healthy is not None else False
2720        '''
2721         True if the datasource is reachable and the credentials are valid.
2722        '''
2723        self.id = id if id is not None else ''
2724        '''
2725         Unique identifier of the Resource.
2726        '''
2727        self.name = name if name is not None else ''
2728        '''
2729         Unique human-readable name of the Resource.
2730        '''
2731        self.password = password if password is not None else ''
2732        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2733        '''
2734         ID of the secret store containing credentials for this resource, if any.
2735        '''
2736        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2737        '''
2738         Tags is a map of key, value pairs.
2739        '''
2740        self.tenant_id = tenant_id if tenant_id is not None else ''
2741
2742    def __repr__(self):
2743        return '<sdm.Azure ' + \
2744            'app_id: ' + repr(self.app_id) + ' ' +\
2745            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2746            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2747            'healthy: ' + repr(self.healthy) + ' ' +\
2748            'id: ' + repr(self.id) + ' ' +\
2749            'name: ' + repr(self.name) + ' ' +\
2750            'password: ' + repr(self.password) + ' ' +\
2751            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2752            'tags: ' + repr(self.tags) + ' ' +\
2753            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
2754            '>'
2755
2756    def to_dict(self):
2757        return {
2758            'app_id': self.app_id,
2759            'bind_interface': self.bind_interface,
2760            'egress_filter': self.egress_filter,
2761            'healthy': self.healthy,
2762            'id': self.id,
2763            'name': self.name,
2764            'password': self.password,
2765            'secret_store_id': self.secret_store_id,
2766            'tags': self.tags,
2767            'tenant_id': self.tenant_id,
2768        }
2769
2770    @classmethod
2771    def from_dict(cls, d):
2772        return cls(
2773            app_id=d.get('app_id'),
2774            bind_interface=d.get('bind_interface'),
2775            egress_filter=d.get('egress_filter'),
2776            healthy=d.get('healthy'),
2777            id=d.get('id'),
2778            name=d.get('name'),
2779            password=d.get('password'),
2780            secret_store_id=d.get('secret_store_id'),
2781            tags=d.get('tags'),
2782            tenant_id=d.get('tenant_id'),
2783        )
Azure( app_id=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, password=None, secret_store_id=None, tags=None, tenant_id=None)
2697    def __init__(
2698        self,
2699        app_id=None,
2700        bind_interface=None,
2701        egress_filter=None,
2702        healthy=None,
2703        id=None,
2704        name=None,
2705        password=None,
2706        secret_store_id=None,
2707        tags=None,
2708        tenant_id=None,
2709    ):
2710        self.app_id = app_id if app_id is not None else ''
2711        self.bind_interface = bind_interface if bind_interface is not None else ''
2712        '''
2713         Bind interface
2714        '''
2715        self.egress_filter = egress_filter if egress_filter is not None else ''
2716        '''
2717         A filter applied to the routing logic to pin datasource to nodes.
2718        '''
2719        self.healthy = healthy if healthy is not None else False
2720        '''
2721         True if the datasource is reachable and the credentials are valid.
2722        '''
2723        self.id = id if id is not None else ''
2724        '''
2725         Unique identifier of the Resource.
2726        '''
2727        self.name = name if name is not None else ''
2728        '''
2729         Unique human-readable name of the Resource.
2730        '''
2731        self.password = password if password is not None else ''
2732        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2733        '''
2734         ID of the secret store containing credentials for this resource, if any.
2735        '''
2736        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2737        '''
2738         Tags is a map of key, value pairs.
2739        '''
2740        self.tenant_id = tenant_id if tenant_id is not None else ''
app_id
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tenant_id
def to_dict(self)
2756    def to_dict(self):
2757        return {
2758            'app_id': self.app_id,
2759            'bind_interface': self.bind_interface,
2760            'egress_filter': self.egress_filter,
2761            'healthy': self.healthy,
2762            'id': self.id,
2763            'name': self.name,
2764            'password': self.password,
2765            'secret_store_id': self.secret_store_id,
2766            'tags': self.tags,
2767            'tenant_id': self.tenant_id,
2768        }
@classmethod
def from_dict(cls, d)
2770    @classmethod
2771    def from_dict(cls, d):
2772        return cls(
2773            app_id=d.get('app_id'),
2774            bind_interface=d.get('bind_interface'),
2775            egress_filter=d.get('egress_filter'),
2776            healthy=d.get('healthy'),
2777            id=d.get('id'),
2778            name=d.get('name'),
2779            password=d.get('password'),
2780            secret_store_id=d.get('secret_store_id'),
2781            tags=d.get('tags'),
2782            tenant_id=d.get('tenant_id'),
2783        )
class AzureCertificate:
2786class AzureCertificate:
2787    __slots__ = [
2788        'app_id',
2789        'bind_interface',
2790        'client_certificate',
2791        'egress_filter',
2792        'healthy',
2793        'id',
2794        'name',
2795        'secret_store_id',
2796        'tags',
2797        'tenant_id',
2798    ]
2799
2800    def __init__(
2801        self,
2802        app_id=None,
2803        bind_interface=None,
2804        client_certificate=None,
2805        egress_filter=None,
2806        healthy=None,
2807        id=None,
2808        name=None,
2809        secret_store_id=None,
2810        tags=None,
2811        tenant_id=None,
2812    ):
2813        self.app_id = app_id if app_id is not None else ''
2814        self.bind_interface = bind_interface if bind_interface is not None else ''
2815        '''
2816         Bind interface
2817        '''
2818        self.client_certificate = client_certificate if client_certificate is not None else ''
2819        self.egress_filter = egress_filter if egress_filter is not None else ''
2820        '''
2821         A filter applied to the routing logic to pin datasource to nodes.
2822        '''
2823        self.healthy = healthy if healthy is not None else False
2824        '''
2825         True if the datasource is reachable and the credentials are valid.
2826        '''
2827        self.id = id if id is not None else ''
2828        '''
2829         Unique identifier of the Resource.
2830        '''
2831        self.name = name if name is not None else ''
2832        '''
2833         Unique human-readable name of the Resource.
2834        '''
2835        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2836        '''
2837         ID of the secret store containing credentials for this resource, if any.
2838        '''
2839        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2840        '''
2841         Tags is a map of key, value pairs.
2842        '''
2843        self.tenant_id = tenant_id if tenant_id is not None else ''
2844
2845    def __repr__(self):
2846        return '<sdm.AzureCertificate ' + \
2847            'app_id: ' + repr(self.app_id) + ' ' +\
2848            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2849            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
2850            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2851            'healthy: ' + repr(self.healthy) + ' ' +\
2852            'id: ' + repr(self.id) + ' ' +\
2853            'name: ' + repr(self.name) + ' ' +\
2854            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2855            'tags: ' + repr(self.tags) + ' ' +\
2856            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
2857            '>'
2858
2859    def to_dict(self):
2860        return {
2861            'app_id': self.app_id,
2862            'bind_interface': self.bind_interface,
2863            'client_certificate': self.client_certificate,
2864            'egress_filter': self.egress_filter,
2865            'healthy': self.healthy,
2866            'id': self.id,
2867            'name': self.name,
2868            'secret_store_id': self.secret_store_id,
2869            'tags': self.tags,
2870            'tenant_id': self.tenant_id,
2871        }
2872
2873    @classmethod
2874    def from_dict(cls, d):
2875        return cls(
2876            app_id=d.get('app_id'),
2877            bind_interface=d.get('bind_interface'),
2878            client_certificate=d.get('client_certificate'),
2879            egress_filter=d.get('egress_filter'),
2880            healthy=d.get('healthy'),
2881            id=d.get('id'),
2882            name=d.get('name'),
2883            secret_store_id=d.get('secret_store_id'),
2884            tags=d.get('tags'),
2885            tenant_id=d.get('tenant_id'),
2886        )
AzureCertificate( app_id=None, bind_interface=None, client_certificate=None, egress_filter=None, healthy=None, id=None, name=None, secret_store_id=None, tags=None, tenant_id=None)
2800    def __init__(
2801        self,
2802        app_id=None,
2803        bind_interface=None,
2804        client_certificate=None,
2805        egress_filter=None,
2806        healthy=None,
2807        id=None,
2808        name=None,
2809        secret_store_id=None,
2810        tags=None,
2811        tenant_id=None,
2812    ):
2813        self.app_id = app_id if app_id is not None else ''
2814        self.bind_interface = bind_interface if bind_interface is not None else ''
2815        '''
2816         Bind interface
2817        '''
2818        self.client_certificate = client_certificate if client_certificate is not None else ''
2819        self.egress_filter = egress_filter if egress_filter is not None else ''
2820        '''
2821         A filter applied to the routing logic to pin datasource to nodes.
2822        '''
2823        self.healthy = healthy if healthy is not None else False
2824        '''
2825         True if the datasource is reachable and the credentials are valid.
2826        '''
2827        self.id = id if id is not None else ''
2828        '''
2829         Unique identifier of the Resource.
2830        '''
2831        self.name = name if name is not None else ''
2832        '''
2833         Unique human-readable name of the Resource.
2834        '''
2835        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2836        '''
2837         ID of the secret store containing credentials for this resource, if any.
2838        '''
2839        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2840        '''
2841         Tags is a map of key, value pairs.
2842        '''
2843        self.tenant_id = tenant_id if tenant_id is not None else ''
app_id
bind_interface

Bind interface

client_certificate
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tenant_id
def to_dict(self)
2859    def to_dict(self):
2860        return {
2861            'app_id': self.app_id,
2862            'bind_interface': self.bind_interface,
2863            'client_certificate': self.client_certificate,
2864            'egress_filter': self.egress_filter,
2865            'healthy': self.healthy,
2866            'id': self.id,
2867            'name': self.name,
2868            'secret_store_id': self.secret_store_id,
2869            'tags': self.tags,
2870            'tenant_id': self.tenant_id,
2871        }
@classmethod
def from_dict(cls, d)
2873    @classmethod
2874    def from_dict(cls, d):
2875        return cls(
2876            app_id=d.get('app_id'),
2877            bind_interface=d.get('bind_interface'),
2878            client_certificate=d.get('client_certificate'),
2879            egress_filter=d.get('egress_filter'),
2880            healthy=d.get('healthy'),
2881            id=d.get('id'),
2882            name=d.get('name'),
2883            secret_store_id=d.get('secret_store_id'),
2884            tags=d.get('tags'),
2885            tenant_id=d.get('tenant_id'),
2886        )
class AzureMysql:
2889class AzureMysql:
2890    '''
2891    AzureMysql is currently unstable, and its API may change, or it may be removed,
2892    without a major version bump.
2893    '''
2894    __slots__ = [
2895        'bind_interface',
2896        'database',
2897        'egress_filter',
2898        'healthy',
2899        'hostname',
2900        'id',
2901        'name',
2902        'password',
2903        'port',
2904        'port_override',
2905        'secret_store_id',
2906        'tags',
2907        'username',
2908    ]
2909
2910    def __init__(
2911        self,
2912        bind_interface=None,
2913        database=None,
2914        egress_filter=None,
2915        healthy=None,
2916        hostname=None,
2917        id=None,
2918        name=None,
2919        password=None,
2920        port=None,
2921        port_override=None,
2922        secret_store_id=None,
2923        tags=None,
2924        username=None,
2925    ):
2926        self.bind_interface = bind_interface if bind_interface is not None else ''
2927        '''
2928         Bind interface
2929        '''
2930        self.database = database if database is not None else ''
2931        self.egress_filter = egress_filter if egress_filter is not None else ''
2932        '''
2933         A filter applied to the routing logic to pin datasource to nodes.
2934        '''
2935        self.healthy = healthy if healthy is not None else False
2936        '''
2937         True if the datasource is reachable and the credentials are valid.
2938        '''
2939        self.hostname = hostname if hostname is not None else ''
2940        self.id = id if id is not None else ''
2941        '''
2942         Unique identifier of the Resource.
2943        '''
2944        self.name = name if name is not None else ''
2945        '''
2946         Unique human-readable name of the Resource.
2947        '''
2948        self.password = password if password is not None else ''
2949        self.port = port if port is not None else 0
2950        self.port_override = port_override if port_override is not None else 0
2951        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2952        '''
2953         ID of the secret store containing credentials for this resource, if any.
2954        '''
2955        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2956        '''
2957         Tags is a map of key, value pairs.
2958        '''
2959        self.username = username if username is not None else ''
2960
2961    def __repr__(self):
2962        return '<sdm.AzureMysql ' + \
2963            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2964            'database: ' + repr(self.database) + ' ' +\
2965            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2966            'healthy: ' + repr(self.healthy) + ' ' +\
2967            'hostname: ' + repr(self.hostname) + ' ' +\
2968            'id: ' + repr(self.id) + ' ' +\
2969            'name: ' + repr(self.name) + ' ' +\
2970            'password: ' + repr(self.password) + ' ' +\
2971            'port: ' + repr(self.port) + ' ' +\
2972            'port_override: ' + repr(self.port_override) + ' ' +\
2973            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2974            'tags: ' + repr(self.tags) + ' ' +\
2975            'username: ' + repr(self.username) + ' ' +\
2976            '>'
2977
2978    def to_dict(self):
2979        return {
2980            'bind_interface': self.bind_interface,
2981            'database': self.database,
2982            'egress_filter': self.egress_filter,
2983            'healthy': self.healthy,
2984            'hostname': self.hostname,
2985            'id': self.id,
2986            'name': self.name,
2987            'password': self.password,
2988            'port': self.port,
2989            'port_override': self.port_override,
2990            'secret_store_id': self.secret_store_id,
2991            'tags': self.tags,
2992            'username': self.username,
2993        }
2994
2995    @classmethod
2996    def from_dict(cls, d):
2997        return cls(
2998            bind_interface=d.get('bind_interface'),
2999            database=d.get('database'),
3000            egress_filter=d.get('egress_filter'),
3001            healthy=d.get('healthy'),
3002            hostname=d.get('hostname'),
3003            id=d.get('id'),
3004            name=d.get('name'),
3005            password=d.get('password'),
3006            port=d.get('port'),
3007            port_override=d.get('port_override'),
3008            secret_store_id=d.get('secret_store_id'),
3009            tags=d.get('tags'),
3010            username=d.get('username'),
3011        )

AzureMysql is currently unstable, and its API may change, or it may be removed, without a major version bump.

AzureMysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2910    def __init__(
2911        self,
2912        bind_interface=None,
2913        database=None,
2914        egress_filter=None,
2915        healthy=None,
2916        hostname=None,
2917        id=None,
2918        name=None,
2919        password=None,
2920        port=None,
2921        port_override=None,
2922        secret_store_id=None,
2923        tags=None,
2924        username=None,
2925    ):
2926        self.bind_interface = bind_interface if bind_interface is not None else ''
2927        '''
2928         Bind interface
2929        '''
2930        self.database = database if database is not None else ''
2931        self.egress_filter = egress_filter if egress_filter is not None else ''
2932        '''
2933         A filter applied to the routing logic to pin datasource to nodes.
2934        '''
2935        self.healthy = healthy if healthy is not None else False
2936        '''
2937         True if the datasource is reachable and the credentials are valid.
2938        '''
2939        self.hostname = hostname if hostname is not None else ''
2940        self.id = id if id is not None else ''
2941        '''
2942         Unique identifier of the Resource.
2943        '''
2944        self.name = name if name is not None else ''
2945        '''
2946         Unique human-readable name of the Resource.
2947        '''
2948        self.password = password if password is not None else ''
2949        self.port = port if port is not None else 0
2950        self.port_override = port_override if port_override is not None else 0
2951        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2952        '''
2953         ID of the secret store containing credentials for this resource, if any.
2954        '''
2955        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2956        '''
2957         Tags is a map of key, value pairs.
2958        '''
2959        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2978    def to_dict(self):
2979        return {
2980            'bind_interface': self.bind_interface,
2981            'database': self.database,
2982            'egress_filter': self.egress_filter,
2983            'healthy': self.healthy,
2984            'hostname': self.hostname,
2985            'id': self.id,
2986            'name': self.name,
2987            'password': self.password,
2988            'port': self.port,
2989            'port_override': self.port_override,
2990            'secret_store_id': self.secret_store_id,
2991            'tags': self.tags,
2992            'username': self.username,
2993        }
@classmethod
def from_dict(cls, d)
2995    @classmethod
2996    def from_dict(cls, d):
2997        return cls(
2998            bind_interface=d.get('bind_interface'),
2999            database=d.get('database'),
3000            egress_filter=d.get('egress_filter'),
3001            healthy=d.get('healthy'),
3002            hostname=d.get('hostname'),
3003            id=d.get('id'),
3004            name=d.get('name'),
3005            password=d.get('password'),
3006            port=d.get('port'),
3007            port_override=d.get('port_override'),
3008            secret_store_id=d.get('secret_store_id'),
3009            tags=d.get('tags'),
3010            username=d.get('username'),
3011        )
class AzurePostgres:
3014class AzurePostgres:
3015    __slots__ = [
3016        'bind_interface',
3017        'database',
3018        'egress_filter',
3019        'healthy',
3020        'hostname',
3021        'id',
3022        'name',
3023        'override_database',
3024        'password',
3025        'port',
3026        'port_override',
3027        'secret_store_id',
3028        'tags',
3029        'username',
3030    ]
3031
3032    def __init__(
3033        self,
3034        bind_interface=None,
3035        database=None,
3036        egress_filter=None,
3037        healthy=None,
3038        hostname=None,
3039        id=None,
3040        name=None,
3041        override_database=None,
3042        password=None,
3043        port=None,
3044        port_override=None,
3045        secret_store_id=None,
3046        tags=None,
3047        username=None,
3048    ):
3049        self.bind_interface = bind_interface if bind_interface is not None else ''
3050        '''
3051         Bind interface
3052        '''
3053        self.database = database if database is not None else ''
3054        self.egress_filter = egress_filter if egress_filter is not None else ''
3055        '''
3056         A filter applied to the routing logic to pin datasource to nodes.
3057        '''
3058        self.healthy = healthy if healthy is not None else False
3059        '''
3060         True if the datasource is reachable and the credentials are valid.
3061        '''
3062        self.hostname = hostname if hostname is not None else ''
3063        self.id = id if id is not None else ''
3064        '''
3065         Unique identifier of the Resource.
3066        '''
3067        self.name = name if name is not None else ''
3068        '''
3069         Unique human-readable name of the Resource.
3070        '''
3071        self.override_database = override_database if override_database is not None else False
3072        self.password = password if password is not None else ''
3073        self.port = port if port is not None else 0
3074        self.port_override = port_override if port_override is not None else 0
3075        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3076        '''
3077         ID of the secret store containing credentials for this resource, if any.
3078        '''
3079        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3080        '''
3081         Tags is a map of key, value pairs.
3082        '''
3083        self.username = username if username is not None else ''
3084
3085    def __repr__(self):
3086        return '<sdm.AzurePostgres ' + \
3087            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3088            'database: ' + repr(self.database) + ' ' +\
3089            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3090            'healthy: ' + repr(self.healthy) + ' ' +\
3091            'hostname: ' + repr(self.hostname) + ' ' +\
3092            'id: ' + repr(self.id) + ' ' +\
3093            'name: ' + repr(self.name) + ' ' +\
3094            'override_database: ' + repr(self.override_database) + ' ' +\
3095            'password: ' + repr(self.password) + ' ' +\
3096            'port: ' + repr(self.port) + ' ' +\
3097            'port_override: ' + repr(self.port_override) + ' ' +\
3098            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3099            'tags: ' + repr(self.tags) + ' ' +\
3100            'username: ' + repr(self.username) + ' ' +\
3101            '>'
3102
3103    def to_dict(self):
3104        return {
3105            'bind_interface': self.bind_interface,
3106            'database': self.database,
3107            'egress_filter': self.egress_filter,
3108            'healthy': self.healthy,
3109            'hostname': self.hostname,
3110            'id': self.id,
3111            'name': self.name,
3112            'override_database': self.override_database,
3113            'password': self.password,
3114            'port': self.port,
3115            'port_override': self.port_override,
3116            'secret_store_id': self.secret_store_id,
3117            'tags': self.tags,
3118            'username': self.username,
3119        }
3120
3121    @classmethod
3122    def from_dict(cls, d):
3123        return cls(
3124            bind_interface=d.get('bind_interface'),
3125            database=d.get('database'),
3126            egress_filter=d.get('egress_filter'),
3127            healthy=d.get('healthy'),
3128            hostname=d.get('hostname'),
3129            id=d.get('id'),
3130            name=d.get('name'),
3131            override_database=d.get('override_database'),
3132            password=d.get('password'),
3133            port=d.get('port'),
3134            port_override=d.get('port_override'),
3135            secret_store_id=d.get('secret_store_id'),
3136            tags=d.get('tags'),
3137            username=d.get('username'),
3138        )
AzurePostgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3032    def __init__(
3033        self,
3034        bind_interface=None,
3035        database=None,
3036        egress_filter=None,
3037        healthy=None,
3038        hostname=None,
3039        id=None,
3040        name=None,
3041        override_database=None,
3042        password=None,
3043        port=None,
3044        port_override=None,
3045        secret_store_id=None,
3046        tags=None,
3047        username=None,
3048    ):
3049        self.bind_interface = bind_interface if bind_interface is not None else ''
3050        '''
3051         Bind interface
3052        '''
3053        self.database = database if database is not None else ''
3054        self.egress_filter = egress_filter if egress_filter is not None else ''
3055        '''
3056         A filter applied to the routing logic to pin datasource to nodes.
3057        '''
3058        self.healthy = healthy if healthy is not None else False
3059        '''
3060         True if the datasource is reachable and the credentials are valid.
3061        '''
3062        self.hostname = hostname if hostname is not None else ''
3063        self.id = id if id is not None else ''
3064        '''
3065         Unique identifier of the Resource.
3066        '''
3067        self.name = name if name is not None else ''
3068        '''
3069         Unique human-readable name of the Resource.
3070        '''
3071        self.override_database = override_database if override_database is not None else False
3072        self.password = password if password is not None else ''
3073        self.port = port if port is not None else 0
3074        self.port_override = port_override if port_override is not None else 0
3075        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3076        '''
3077         ID of the secret store containing credentials for this resource, if any.
3078        '''
3079        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3080        '''
3081         Tags is a map of key, value pairs.
3082        '''
3083        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3103    def to_dict(self):
3104        return {
3105            'bind_interface': self.bind_interface,
3106            'database': self.database,
3107            'egress_filter': self.egress_filter,
3108            'healthy': self.healthy,
3109            'hostname': self.hostname,
3110            'id': self.id,
3111            'name': self.name,
3112            'override_database': self.override_database,
3113            'password': self.password,
3114            'port': self.port,
3115            'port_override': self.port_override,
3116            'secret_store_id': self.secret_store_id,
3117            'tags': self.tags,
3118            'username': self.username,
3119        }
@classmethod
def from_dict(cls, d)
3121    @classmethod
3122    def from_dict(cls, d):
3123        return cls(
3124            bind_interface=d.get('bind_interface'),
3125            database=d.get('database'),
3126            egress_filter=d.get('egress_filter'),
3127            healthy=d.get('healthy'),
3128            hostname=d.get('hostname'),
3129            id=d.get('id'),
3130            name=d.get('name'),
3131            override_database=d.get('override_database'),
3132            password=d.get('password'),
3133            port=d.get('port'),
3134            port_override=d.get('port_override'),
3135            secret_store_id=d.get('secret_store_id'),
3136            tags=d.get('tags'),
3137            username=d.get('username'),
3138        )
class AzureStore:
3141class AzureStore:
3142    __slots__ = [
3143        'id',
3144        'name',
3145        'tags',
3146        'vault_uri',
3147    ]
3148
3149    def __init__(
3150        self,
3151        id=None,
3152        name=None,
3153        tags=None,
3154        vault_uri=None,
3155    ):
3156        self.id = id if id is not None else ''
3157        '''
3158         Unique identifier of the SecretStore.
3159        '''
3160        self.name = name if name is not None else ''
3161        '''
3162         Unique human-readable name of the SecretStore.
3163        '''
3164        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3165        '''
3166         Tags is a map of key, value pairs.
3167        '''
3168        self.vault_uri = vault_uri if vault_uri is not None else ''
3169
3170    def __repr__(self):
3171        return '<sdm.AzureStore ' + \
3172            'id: ' + repr(self.id) + ' ' +\
3173            'name: ' + repr(self.name) + ' ' +\
3174            'tags: ' + repr(self.tags) + ' ' +\
3175            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
3176            '>'
3177
3178    def to_dict(self):
3179        return {
3180            'id': self.id,
3181            'name': self.name,
3182            'tags': self.tags,
3183            'vault_uri': self.vault_uri,
3184        }
3185
3186    @classmethod
3187    def from_dict(cls, d):
3188        return cls(
3189            id=d.get('id'),
3190            name=d.get('name'),
3191            tags=d.get('tags'),
3192            vault_uri=d.get('vault_uri'),
3193        )
AzureStore(id=None, name=None, tags=None, vault_uri=None)
3149    def __init__(
3150        self,
3151        id=None,
3152        name=None,
3153        tags=None,
3154        vault_uri=None,
3155    ):
3156        self.id = id if id is not None else ''
3157        '''
3158         Unique identifier of the SecretStore.
3159        '''
3160        self.name = name if name is not None else ''
3161        '''
3162         Unique human-readable name of the SecretStore.
3163        '''
3164        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3165        '''
3166         Tags is a map of key, value pairs.
3167        '''
3168        self.vault_uri = vault_uri if vault_uri is not None else ''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

vault_uri
def to_dict(self)
3178    def to_dict(self):
3179        return {
3180            'id': self.id,
3181            'name': self.name,
3182            'tags': self.tags,
3183            'vault_uri': self.vault_uri,
3184        }
@classmethod
def from_dict(cls, d)
3186    @classmethod
3187    def from_dict(cls, d):
3188        return cls(
3189            id=d.get('id'),
3190            name=d.get('name'),
3191            tags=d.get('tags'),
3192            vault_uri=d.get('vault_uri'),
3193        )
class BigQuery:
3196class BigQuery:
3197    __slots__ = [
3198        'bind_interface',
3199        'egress_filter',
3200        'endpoint',
3201        'healthy',
3202        'id',
3203        'name',
3204        'port_override',
3205        'private_key',
3206        'project',
3207        'secret_store_id',
3208        'tags',
3209        'username',
3210    ]
3211
3212    def __init__(
3213        self,
3214        bind_interface=None,
3215        egress_filter=None,
3216        endpoint=None,
3217        healthy=None,
3218        id=None,
3219        name=None,
3220        port_override=None,
3221        private_key=None,
3222        project=None,
3223        secret_store_id=None,
3224        tags=None,
3225        username=None,
3226    ):
3227        self.bind_interface = bind_interface if bind_interface is not None else ''
3228        '''
3229         Bind interface
3230        '''
3231        self.egress_filter = egress_filter if egress_filter is not None else ''
3232        '''
3233         A filter applied to the routing logic to pin datasource to nodes.
3234        '''
3235        self.endpoint = endpoint if endpoint is not None else ''
3236        self.healthy = healthy if healthy is not None else False
3237        '''
3238         True if the datasource is reachable and the credentials are valid.
3239        '''
3240        self.id = id if id is not None else ''
3241        '''
3242         Unique identifier of the Resource.
3243        '''
3244        self.name = name if name is not None else ''
3245        '''
3246         Unique human-readable name of the Resource.
3247        '''
3248        self.port_override = port_override if port_override is not None else 0
3249        self.private_key = private_key if private_key is not None else ''
3250        self.project = project if project is not None else ''
3251        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3252        '''
3253         ID of the secret store containing credentials for this resource, if any.
3254        '''
3255        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3256        '''
3257         Tags is a map of key, value pairs.
3258        '''
3259        self.username = username if username is not None else ''
3260
3261    def __repr__(self):
3262        return '<sdm.BigQuery ' + \
3263            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3264            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3265            'endpoint: ' + repr(self.endpoint) + ' ' +\
3266            'healthy: ' + repr(self.healthy) + ' ' +\
3267            'id: ' + repr(self.id) + ' ' +\
3268            'name: ' + repr(self.name) + ' ' +\
3269            'port_override: ' + repr(self.port_override) + ' ' +\
3270            'private_key: ' + repr(self.private_key) + ' ' +\
3271            'project: ' + repr(self.project) + ' ' +\
3272            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3273            'tags: ' + repr(self.tags) + ' ' +\
3274            'username: ' + repr(self.username) + ' ' +\
3275            '>'
3276
3277    def to_dict(self):
3278        return {
3279            'bind_interface': self.bind_interface,
3280            'egress_filter': self.egress_filter,
3281            'endpoint': self.endpoint,
3282            'healthy': self.healthy,
3283            'id': self.id,
3284            'name': self.name,
3285            'port_override': self.port_override,
3286            'private_key': self.private_key,
3287            'project': self.project,
3288            'secret_store_id': self.secret_store_id,
3289            'tags': self.tags,
3290            'username': self.username,
3291        }
3292
3293    @classmethod
3294    def from_dict(cls, d):
3295        return cls(
3296            bind_interface=d.get('bind_interface'),
3297            egress_filter=d.get('egress_filter'),
3298            endpoint=d.get('endpoint'),
3299            healthy=d.get('healthy'),
3300            id=d.get('id'),
3301            name=d.get('name'),
3302            port_override=d.get('port_override'),
3303            private_key=d.get('private_key'),
3304            project=d.get('project'),
3305            secret_store_id=d.get('secret_store_id'),
3306            tags=d.get('tags'),
3307            username=d.get('username'),
3308        )
BigQuery( bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, private_key=None, project=None, secret_store_id=None, tags=None, username=None)
3212    def __init__(
3213        self,
3214        bind_interface=None,
3215        egress_filter=None,
3216        endpoint=None,
3217        healthy=None,
3218        id=None,
3219        name=None,
3220        port_override=None,
3221        private_key=None,
3222        project=None,
3223        secret_store_id=None,
3224        tags=None,
3225        username=None,
3226    ):
3227        self.bind_interface = bind_interface if bind_interface is not None else ''
3228        '''
3229         Bind interface
3230        '''
3231        self.egress_filter = egress_filter if egress_filter is not None else ''
3232        '''
3233         A filter applied to the routing logic to pin datasource to nodes.
3234        '''
3235        self.endpoint = endpoint if endpoint is not None else ''
3236        self.healthy = healthy if healthy is not None else False
3237        '''
3238         True if the datasource is reachable and the credentials are valid.
3239        '''
3240        self.id = id if id is not None else ''
3241        '''
3242         Unique identifier of the Resource.
3243        '''
3244        self.name = name if name is not None else ''
3245        '''
3246         Unique human-readable name of the Resource.
3247        '''
3248        self.port_override = port_override if port_override is not None else 0
3249        self.private_key = private_key if private_key is not None else ''
3250        self.project = project if project is not None else ''
3251        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3252        '''
3253         ID of the secret store containing credentials for this resource, if any.
3254        '''
3255        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3256        '''
3257         Tags is a map of key, value pairs.
3258        '''
3259        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
private_key
project
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3277    def to_dict(self):
3278        return {
3279            'bind_interface': self.bind_interface,
3280            'egress_filter': self.egress_filter,
3281            'endpoint': self.endpoint,
3282            'healthy': self.healthy,
3283            'id': self.id,
3284            'name': self.name,
3285            'port_override': self.port_override,
3286            'private_key': self.private_key,
3287            'project': self.project,
3288            'secret_store_id': self.secret_store_id,
3289            'tags': self.tags,
3290            'username': self.username,
3291        }
@classmethod
def from_dict(cls, d)
3293    @classmethod
3294    def from_dict(cls, d):
3295        return cls(
3296            bind_interface=d.get('bind_interface'),
3297            egress_filter=d.get('egress_filter'),
3298            endpoint=d.get('endpoint'),
3299            healthy=d.get('healthy'),
3300            id=d.get('id'),
3301            name=d.get('name'),
3302            port_override=d.get('port_override'),
3303            private_key=d.get('private_key'),
3304            project=d.get('project'),
3305            secret_store_id=d.get('secret_store_id'),
3306            tags=d.get('tags'),
3307            username=d.get('username'),
3308        )
class Cassandra:
3311class Cassandra:
3312    __slots__ = [
3313        'bind_interface',
3314        'egress_filter',
3315        'healthy',
3316        'hostname',
3317        'id',
3318        'name',
3319        'password',
3320        'port',
3321        'port_override',
3322        'secret_store_id',
3323        'tags',
3324        'tls_required',
3325        'username',
3326    ]
3327
3328    def __init__(
3329        self,
3330        bind_interface=None,
3331        egress_filter=None,
3332        healthy=None,
3333        hostname=None,
3334        id=None,
3335        name=None,
3336        password=None,
3337        port=None,
3338        port_override=None,
3339        secret_store_id=None,
3340        tags=None,
3341        tls_required=None,
3342        username=None,
3343    ):
3344        self.bind_interface = bind_interface if bind_interface is not None else ''
3345        '''
3346         Bind interface
3347        '''
3348        self.egress_filter = egress_filter if egress_filter is not None else ''
3349        '''
3350         A filter applied to the routing logic to pin datasource to nodes.
3351        '''
3352        self.healthy = healthy if healthy is not None else False
3353        '''
3354         True if the datasource is reachable and the credentials are valid.
3355        '''
3356        self.hostname = hostname if hostname is not None else ''
3357        self.id = id if id is not None else ''
3358        '''
3359         Unique identifier of the Resource.
3360        '''
3361        self.name = name if name is not None else ''
3362        '''
3363         Unique human-readable name of the Resource.
3364        '''
3365        self.password = password if password is not None else ''
3366        self.port = port if port is not None else 0
3367        self.port_override = port_override if port_override is not None else 0
3368        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3369        '''
3370         ID of the secret store containing credentials for this resource, if any.
3371        '''
3372        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3373        '''
3374         Tags is a map of key, value pairs.
3375        '''
3376        self.tls_required = tls_required if tls_required is not None else False
3377        self.username = username if username is not None else ''
3378
3379    def __repr__(self):
3380        return '<sdm.Cassandra ' + \
3381            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3382            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3383            'healthy: ' + repr(self.healthy) + ' ' +\
3384            'hostname: ' + repr(self.hostname) + ' ' +\
3385            'id: ' + repr(self.id) + ' ' +\
3386            'name: ' + repr(self.name) + ' ' +\
3387            'password: ' + repr(self.password) + ' ' +\
3388            'port: ' + repr(self.port) + ' ' +\
3389            'port_override: ' + repr(self.port_override) + ' ' +\
3390            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3391            'tags: ' + repr(self.tags) + ' ' +\
3392            'tls_required: ' + repr(self.tls_required) + ' ' +\
3393            'username: ' + repr(self.username) + ' ' +\
3394            '>'
3395
3396    def to_dict(self):
3397        return {
3398            'bind_interface': self.bind_interface,
3399            'egress_filter': self.egress_filter,
3400            'healthy': self.healthy,
3401            'hostname': self.hostname,
3402            'id': self.id,
3403            'name': self.name,
3404            'password': self.password,
3405            'port': self.port,
3406            'port_override': self.port_override,
3407            'secret_store_id': self.secret_store_id,
3408            'tags': self.tags,
3409            'tls_required': self.tls_required,
3410            'username': self.username,
3411        }
3412
3413    @classmethod
3414    def from_dict(cls, d):
3415        return cls(
3416            bind_interface=d.get('bind_interface'),
3417            egress_filter=d.get('egress_filter'),
3418            healthy=d.get('healthy'),
3419            hostname=d.get('hostname'),
3420            id=d.get('id'),
3421            name=d.get('name'),
3422            password=d.get('password'),
3423            port=d.get('port'),
3424            port_override=d.get('port_override'),
3425            secret_store_id=d.get('secret_store_id'),
3426            tags=d.get('tags'),
3427            tls_required=d.get('tls_required'),
3428            username=d.get('username'),
3429        )
Cassandra( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
3328    def __init__(
3329        self,
3330        bind_interface=None,
3331        egress_filter=None,
3332        healthy=None,
3333        hostname=None,
3334        id=None,
3335        name=None,
3336        password=None,
3337        port=None,
3338        port_override=None,
3339        secret_store_id=None,
3340        tags=None,
3341        tls_required=None,
3342        username=None,
3343    ):
3344        self.bind_interface = bind_interface if bind_interface is not None else ''
3345        '''
3346         Bind interface
3347        '''
3348        self.egress_filter = egress_filter if egress_filter is not None else ''
3349        '''
3350         A filter applied to the routing logic to pin datasource to nodes.
3351        '''
3352        self.healthy = healthy if healthy is not None else False
3353        '''
3354         True if the datasource is reachable and the credentials are valid.
3355        '''
3356        self.hostname = hostname if hostname is not None else ''
3357        self.id = id if id is not None else ''
3358        '''
3359         Unique identifier of the Resource.
3360        '''
3361        self.name = name if name is not None else ''
3362        '''
3363         Unique human-readable name of the Resource.
3364        '''
3365        self.password = password if password is not None else ''
3366        self.port = port if port is not None else 0
3367        self.port_override = port_override if port_override is not None else 0
3368        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3369        '''
3370         ID of the secret store containing credentials for this resource, if any.
3371        '''
3372        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3373        '''
3374         Tags is a map of key, value pairs.
3375        '''
3376        self.tls_required = tls_required if tls_required is not None else False
3377        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
3396    def to_dict(self):
3397        return {
3398            'bind_interface': self.bind_interface,
3399            'egress_filter': self.egress_filter,
3400            'healthy': self.healthy,
3401            'hostname': self.hostname,
3402            'id': self.id,
3403            'name': self.name,
3404            'password': self.password,
3405            'port': self.port,
3406            'port_override': self.port_override,
3407            'secret_store_id': self.secret_store_id,
3408            'tags': self.tags,
3409            'tls_required': self.tls_required,
3410            'username': self.username,
3411        }
@classmethod
def from_dict(cls, d)
3413    @classmethod
3414    def from_dict(cls, d):
3415        return cls(
3416            bind_interface=d.get('bind_interface'),
3417            egress_filter=d.get('egress_filter'),
3418            healthy=d.get('healthy'),
3419            hostname=d.get('hostname'),
3420            id=d.get('id'),
3421            name=d.get('name'),
3422            password=d.get('password'),
3423            port=d.get('port'),
3424            port_override=d.get('port_override'),
3425            secret_store_id=d.get('secret_store_id'),
3426            tags=d.get('tags'),
3427            tls_required=d.get('tls_required'),
3428            username=d.get('username'),
3429        )
class Citus:
3432class Citus:
3433    __slots__ = [
3434        'bind_interface',
3435        'database',
3436        'egress_filter',
3437        'healthy',
3438        'hostname',
3439        'id',
3440        'name',
3441        'override_database',
3442        'password',
3443        'port',
3444        'port_override',
3445        'secret_store_id',
3446        'tags',
3447        'username',
3448    ]
3449
3450    def __init__(
3451        self,
3452        bind_interface=None,
3453        database=None,
3454        egress_filter=None,
3455        healthy=None,
3456        hostname=None,
3457        id=None,
3458        name=None,
3459        override_database=None,
3460        password=None,
3461        port=None,
3462        port_override=None,
3463        secret_store_id=None,
3464        tags=None,
3465        username=None,
3466    ):
3467        self.bind_interface = bind_interface if bind_interface is not None else ''
3468        '''
3469         Bind interface
3470        '''
3471        self.database = database if database is not None else ''
3472        self.egress_filter = egress_filter if egress_filter is not None else ''
3473        '''
3474         A filter applied to the routing logic to pin datasource to nodes.
3475        '''
3476        self.healthy = healthy if healthy is not None else False
3477        '''
3478         True if the datasource is reachable and the credentials are valid.
3479        '''
3480        self.hostname = hostname if hostname is not None else ''
3481        self.id = id if id is not None else ''
3482        '''
3483         Unique identifier of the Resource.
3484        '''
3485        self.name = name if name is not None else ''
3486        '''
3487         Unique human-readable name of the Resource.
3488        '''
3489        self.override_database = override_database if override_database is not None else False
3490        self.password = password if password is not None else ''
3491        self.port = port if port is not None else 0
3492        self.port_override = port_override if port_override is not None else 0
3493        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3494        '''
3495         ID of the secret store containing credentials for this resource, if any.
3496        '''
3497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3498        '''
3499         Tags is a map of key, value pairs.
3500        '''
3501        self.username = username if username is not None else ''
3502
3503    def __repr__(self):
3504        return '<sdm.Citus ' + \
3505            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3506            'database: ' + repr(self.database) + ' ' +\
3507            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3508            'healthy: ' + repr(self.healthy) + ' ' +\
3509            'hostname: ' + repr(self.hostname) + ' ' +\
3510            'id: ' + repr(self.id) + ' ' +\
3511            'name: ' + repr(self.name) + ' ' +\
3512            'override_database: ' + repr(self.override_database) + ' ' +\
3513            'password: ' + repr(self.password) + ' ' +\
3514            'port: ' + repr(self.port) + ' ' +\
3515            'port_override: ' + repr(self.port_override) + ' ' +\
3516            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3517            'tags: ' + repr(self.tags) + ' ' +\
3518            'username: ' + repr(self.username) + ' ' +\
3519            '>'
3520
3521    def to_dict(self):
3522        return {
3523            'bind_interface': self.bind_interface,
3524            'database': self.database,
3525            'egress_filter': self.egress_filter,
3526            'healthy': self.healthy,
3527            'hostname': self.hostname,
3528            'id': self.id,
3529            'name': self.name,
3530            'override_database': self.override_database,
3531            'password': self.password,
3532            'port': self.port,
3533            'port_override': self.port_override,
3534            'secret_store_id': self.secret_store_id,
3535            'tags': self.tags,
3536            'username': self.username,
3537        }
3538
3539    @classmethod
3540    def from_dict(cls, d):
3541        return cls(
3542            bind_interface=d.get('bind_interface'),
3543            database=d.get('database'),
3544            egress_filter=d.get('egress_filter'),
3545            healthy=d.get('healthy'),
3546            hostname=d.get('hostname'),
3547            id=d.get('id'),
3548            name=d.get('name'),
3549            override_database=d.get('override_database'),
3550            password=d.get('password'),
3551            port=d.get('port'),
3552            port_override=d.get('port_override'),
3553            secret_store_id=d.get('secret_store_id'),
3554            tags=d.get('tags'),
3555            username=d.get('username'),
3556        )
Citus( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3450    def __init__(
3451        self,
3452        bind_interface=None,
3453        database=None,
3454        egress_filter=None,
3455        healthy=None,
3456        hostname=None,
3457        id=None,
3458        name=None,
3459        override_database=None,
3460        password=None,
3461        port=None,
3462        port_override=None,
3463        secret_store_id=None,
3464        tags=None,
3465        username=None,
3466    ):
3467        self.bind_interface = bind_interface if bind_interface is not None else ''
3468        '''
3469         Bind interface
3470        '''
3471        self.database = database if database is not None else ''
3472        self.egress_filter = egress_filter if egress_filter is not None else ''
3473        '''
3474         A filter applied to the routing logic to pin datasource to nodes.
3475        '''
3476        self.healthy = healthy if healthy is not None else False
3477        '''
3478         True if the datasource is reachable and the credentials are valid.
3479        '''
3480        self.hostname = hostname if hostname is not None else ''
3481        self.id = id if id is not None else ''
3482        '''
3483         Unique identifier of the Resource.
3484        '''
3485        self.name = name if name is not None else ''
3486        '''
3487         Unique human-readable name of the Resource.
3488        '''
3489        self.override_database = override_database if override_database is not None else False
3490        self.password = password if password is not None else ''
3491        self.port = port if port is not None else 0
3492        self.port_override = port_override if port_override is not None else 0
3493        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3494        '''
3495         ID of the secret store containing credentials for this resource, if any.
3496        '''
3497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3498        '''
3499         Tags is a map of key, value pairs.
3500        '''
3501        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3521    def to_dict(self):
3522        return {
3523            'bind_interface': self.bind_interface,
3524            'database': self.database,
3525            'egress_filter': self.egress_filter,
3526            'healthy': self.healthy,
3527            'hostname': self.hostname,
3528            'id': self.id,
3529            'name': self.name,
3530            'override_database': self.override_database,
3531            'password': self.password,
3532            'port': self.port,
3533            'port_override': self.port_override,
3534            'secret_store_id': self.secret_store_id,
3535            'tags': self.tags,
3536            'username': self.username,
3537        }
@classmethod
def from_dict(cls, d)
3539    @classmethod
3540    def from_dict(cls, d):
3541        return cls(
3542            bind_interface=d.get('bind_interface'),
3543            database=d.get('database'),
3544            egress_filter=d.get('egress_filter'),
3545            healthy=d.get('healthy'),
3546            hostname=d.get('hostname'),
3547            id=d.get('id'),
3548            name=d.get('name'),
3549            override_database=d.get('override_database'),
3550            password=d.get('password'),
3551            port=d.get('port'),
3552            port_override=d.get('port_override'),
3553            secret_store_id=d.get('secret_store_id'),
3554            tags=d.get('tags'),
3555            username=d.get('username'),
3556        )
class Clustrix:
3559class Clustrix:
3560    __slots__ = [
3561        'bind_interface',
3562        'database',
3563        'egress_filter',
3564        'healthy',
3565        'hostname',
3566        'id',
3567        'name',
3568        'password',
3569        'port',
3570        'port_override',
3571        'secret_store_id',
3572        'tags',
3573        'username',
3574    ]
3575
3576    def __init__(
3577        self,
3578        bind_interface=None,
3579        database=None,
3580        egress_filter=None,
3581        healthy=None,
3582        hostname=None,
3583        id=None,
3584        name=None,
3585        password=None,
3586        port=None,
3587        port_override=None,
3588        secret_store_id=None,
3589        tags=None,
3590        username=None,
3591    ):
3592        self.bind_interface = bind_interface if bind_interface is not None else ''
3593        '''
3594         Bind interface
3595        '''
3596        self.database = database if database is not None else ''
3597        self.egress_filter = egress_filter if egress_filter is not None else ''
3598        '''
3599         A filter applied to the routing logic to pin datasource to nodes.
3600        '''
3601        self.healthy = healthy if healthy is not None else False
3602        '''
3603         True if the datasource is reachable and the credentials are valid.
3604        '''
3605        self.hostname = hostname if hostname is not None else ''
3606        self.id = id if id is not None else ''
3607        '''
3608         Unique identifier of the Resource.
3609        '''
3610        self.name = name if name is not None else ''
3611        '''
3612         Unique human-readable name of the Resource.
3613        '''
3614        self.password = password if password is not None else ''
3615        self.port = port if port is not None else 0
3616        self.port_override = port_override if port_override is not None else 0
3617        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3618        '''
3619         ID of the secret store containing credentials for this resource, if any.
3620        '''
3621        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3622        '''
3623         Tags is a map of key, value pairs.
3624        '''
3625        self.username = username if username is not None else ''
3626
3627    def __repr__(self):
3628        return '<sdm.Clustrix ' + \
3629            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3630            'database: ' + repr(self.database) + ' ' +\
3631            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3632            'healthy: ' + repr(self.healthy) + ' ' +\
3633            'hostname: ' + repr(self.hostname) + ' ' +\
3634            'id: ' + repr(self.id) + ' ' +\
3635            'name: ' + repr(self.name) + ' ' +\
3636            'password: ' + repr(self.password) + ' ' +\
3637            'port: ' + repr(self.port) + ' ' +\
3638            'port_override: ' + repr(self.port_override) + ' ' +\
3639            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3640            'tags: ' + repr(self.tags) + ' ' +\
3641            'username: ' + repr(self.username) + ' ' +\
3642            '>'
3643
3644    def to_dict(self):
3645        return {
3646            'bind_interface': self.bind_interface,
3647            'database': self.database,
3648            'egress_filter': self.egress_filter,
3649            'healthy': self.healthy,
3650            'hostname': self.hostname,
3651            'id': self.id,
3652            'name': self.name,
3653            'password': self.password,
3654            'port': self.port,
3655            'port_override': self.port_override,
3656            'secret_store_id': self.secret_store_id,
3657            'tags': self.tags,
3658            'username': self.username,
3659        }
3660
3661    @classmethod
3662    def from_dict(cls, d):
3663        return cls(
3664            bind_interface=d.get('bind_interface'),
3665            database=d.get('database'),
3666            egress_filter=d.get('egress_filter'),
3667            healthy=d.get('healthy'),
3668            hostname=d.get('hostname'),
3669            id=d.get('id'),
3670            name=d.get('name'),
3671            password=d.get('password'),
3672            port=d.get('port'),
3673            port_override=d.get('port_override'),
3674            secret_store_id=d.get('secret_store_id'),
3675            tags=d.get('tags'),
3676            username=d.get('username'),
3677        )
Clustrix( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3576    def __init__(
3577        self,
3578        bind_interface=None,
3579        database=None,
3580        egress_filter=None,
3581        healthy=None,
3582        hostname=None,
3583        id=None,
3584        name=None,
3585        password=None,
3586        port=None,
3587        port_override=None,
3588        secret_store_id=None,
3589        tags=None,
3590        username=None,
3591    ):
3592        self.bind_interface = bind_interface if bind_interface is not None else ''
3593        '''
3594         Bind interface
3595        '''
3596        self.database = database if database is not None else ''
3597        self.egress_filter = egress_filter if egress_filter is not None else ''
3598        '''
3599         A filter applied to the routing logic to pin datasource to nodes.
3600        '''
3601        self.healthy = healthy if healthy is not None else False
3602        '''
3603         True if the datasource is reachable and the credentials are valid.
3604        '''
3605        self.hostname = hostname if hostname is not None else ''
3606        self.id = id if id is not None else ''
3607        '''
3608         Unique identifier of the Resource.
3609        '''
3610        self.name = name if name is not None else ''
3611        '''
3612         Unique human-readable name of the Resource.
3613        '''
3614        self.password = password if password is not None else ''
3615        self.port = port if port is not None else 0
3616        self.port_override = port_override if port_override is not None else 0
3617        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3618        '''
3619         ID of the secret store containing credentials for this resource, if any.
3620        '''
3621        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3622        '''
3623         Tags is a map of key, value pairs.
3624        '''
3625        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3644    def to_dict(self):
3645        return {
3646            'bind_interface': self.bind_interface,
3647            'database': self.database,
3648            'egress_filter': self.egress_filter,
3649            'healthy': self.healthy,
3650            'hostname': self.hostname,
3651            'id': self.id,
3652            'name': self.name,
3653            'password': self.password,
3654            'port': self.port,
3655            'port_override': self.port_override,
3656            'secret_store_id': self.secret_store_id,
3657            'tags': self.tags,
3658            'username': self.username,
3659        }
@classmethod
def from_dict(cls, d)
3661    @classmethod
3662    def from_dict(cls, d):
3663        return cls(
3664            bind_interface=d.get('bind_interface'),
3665            database=d.get('database'),
3666            egress_filter=d.get('egress_filter'),
3667            healthy=d.get('healthy'),
3668            hostname=d.get('hostname'),
3669            id=d.get('id'),
3670            name=d.get('name'),
3671            password=d.get('password'),
3672            port=d.get('port'),
3673            port_override=d.get('port_override'),
3674            secret_store_id=d.get('secret_store_id'),
3675            tags=d.get('tags'),
3676            username=d.get('username'),
3677        )
class Cockroach:
3680class Cockroach:
3681    __slots__ = [
3682        'bind_interface',
3683        'database',
3684        'egress_filter',
3685        'healthy',
3686        'hostname',
3687        'id',
3688        'name',
3689        'override_database',
3690        'password',
3691        'port',
3692        'port_override',
3693        'secret_store_id',
3694        'tags',
3695        'username',
3696    ]
3697
3698    def __init__(
3699        self,
3700        bind_interface=None,
3701        database=None,
3702        egress_filter=None,
3703        healthy=None,
3704        hostname=None,
3705        id=None,
3706        name=None,
3707        override_database=None,
3708        password=None,
3709        port=None,
3710        port_override=None,
3711        secret_store_id=None,
3712        tags=None,
3713        username=None,
3714    ):
3715        self.bind_interface = bind_interface if bind_interface is not None else ''
3716        '''
3717         Bind interface
3718        '''
3719        self.database = database if database is not None else ''
3720        self.egress_filter = egress_filter if egress_filter is not None else ''
3721        '''
3722         A filter applied to the routing logic to pin datasource to nodes.
3723        '''
3724        self.healthy = healthy if healthy is not None else False
3725        '''
3726         True if the datasource is reachable and the credentials are valid.
3727        '''
3728        self.hostname = hostname if hostname is not None else ''
3729        self.id = id if id is not None else ''
3730        '''
3731         Unique identifier of the Resource.
3732        '''
3733        self.name = name if name is not None else ''
3734        '''
3735         Unique human-readable name of the Resource.
3736        '''
3737        self.override_database = override_database if override_database is not None else False
3738        self.password = password if password is not None else ''
3739        self.port = port if port is not None else 0
3740        self.port_override = port_override if port_override is not None else 0
3741        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3742        '''
3743         ID of the secret store containing credentials for this resource, if any.
3744        '''
3745        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3746        '''
3747         Tags is a map of key, value pairs.
3748        '''
3749        self.username = username if username is not None else ''
3750
3751    def __repr__(self):
3752        return '<sdm.Cockroach ' + \
3753            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3754            'database: ' + repr(self.database) + ' ' +\
3755            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3756            'healthy: ' + repr(self.healthy) + ' ' +\
3757            'hostname: ' + repr(self.hostname) + ' ' +\
3758            'id: ' + repr(self.id) + ' ' +\
3759            'name: ' + repr(self.name) + ' ' +\
3760            'override_database: ' + repr(self.override_database) + ' ' +\
3761            'password: ' + repr(self.password) + ' ' +\
3762            'port: ' + repr(self.port) + ' ' +\
3763            'port_override: ' + repr(self.port_override) + ' ' +\
3764            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3765            'tags: ' + repr(self.tags) + ' ' +\
3766            'username: ' + repr(self.username) + ' ' +\
3767            '>'
3768
3769    def to_dict(self):
3770        return {
3771            'bind_interface': self.bind_interface,
3772            'database': self.database,
3773            'egress_filter': self.egress_filter,
3774            'healthy': self.healthy,
3775            'hostname': self.hostname,
3776            'id': self.id,
3777            'name': self.name,
3778            'override_database': self.override_database,
3779            'password': self.password,
3780            'port': self.port,
3781            'port_override': self.port_override,
3782            'secret_store_id': self.secret_store_id,
3783            'tags': self.tags,
3784            'username': self.username,
3785        }
3786
3787    @classmethod
3788    def from_dict(cls, d):
3789        return cls(
3790            bind_interface=d.get('bind_interface'),
3791            database=d.get('database'),
3792            egress_filter=d.get('egress_filter'),
3793            healthy=d.get('healthy'),
3794            hostname=d.get('hostname'),
3795            id=d.get('id'),
3796            name=d.get('name'),
3797            override_database=d.get('override_database'),
3798            password=d.get('password'),
3799            port=d.get('port'),
3800            port_override=d.get('port_override'),
3801            secret_store_id=d.get('secret_store_id'),
3802            tags=d.get('tags'),
3803            username=d.get('username'),
3804        )
Cockroach( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3698    def __init__(
3699        self,
3700        bind_interface=None,
3701        database=None,
3702        egress_filter=None,
3703        healthy=None,
3704        hostname=None,
3705        id=None,
3706        name=None,
3707        override_database=None,
3708        password=None,
3709        port=None,
3710        port_override=None,
3711        secret_store_id=None,
3712        tags=None,
3713        username=None,
3714    ):
3715        self.bind_interface = bind_interface if bind_interface is not None else ''
3716        '''
3717         Bind interface
3718        '''
3719        self.database = database if database is not None else ''
3720        self.egress_filter = egress_filter if egress_filter is not None else ''
3721        '''
3722         A filter applied to the routing logic to pin datasource to nodes.
3723        '''
3724        self.healthy = healthy if healthy is not None else False
3725        '''
3726         True if the datasource is reachable and the credentials are valid.
3727        '''
3728        self.hostname = hostname if hostname is not None else ''
3729        self.id = id if id is not None else ''
3730        '''
3731         Unique identifier of the Resource.
3732        '''
3733        self.name = name if name is not None else ''
3734        '''
3735         Unique human-readable name of the Resource.
3736        '''
3737        self.override_database = override_database if override_database is not None else False
3738        self.password = password if password is not None else ''
3739        self.port = port if port is not None else 0
3740        self.port_override = port_override if port_override is not None else 0
3741        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3742        '''
3743         ID of the secret store containing credentials for this resource, if any.
3744        '''
3745        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3746        '''
3747         Tags is a map of key, value pairs.
3748        '''
3749        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3769    def to_dict(self):
3770        return {
3771            'bind_interface': self.bind_interface,
3772            'database': self.database,
3773            'egress_filter': self.egress_filter,
3774            'healthy': self.healthy,
3775            'hostname': self.hostname,
3776            'id': self.id,
3777            'name': self.name,
3778            'override_database': self.override_database,
3779            'password': self.password,
3780            'port': self.port,
3781            'port_override': self.port_override,
3782            'secret_store_id': self.secret_store_id,
3783            'tags': self.tags,
3784            'username': self.username,
3785        }
@classmethod
def from_dict(cls, d)
3787    @classmethod
3788    def from_dict(cls, d):
3789        return cls(
3790            bind_interface=d.get('bind_interface'),
3791            database=d.get('database'),
3792            egress_filter=d.get('egress_filter'),
3793            healthy=d.get('healthy'),
3794            hostname=d.get('hostname'),
3795            id=d.get('id'),
3796            name=d.get('name'),
3797            override_database=d.get('override_database'),
3798            password=d.get('password'),
3799            port=d.get('port'),
3800            port_override=d.get('port_override'),
3801            secret_store_id=d.get('secret_store_id'),
3802            tags=d.get('tags'),
3803            username=d.get('username'),
3804        )
class ControlPanelGetSSHCAPublicKeyResponse:
3807class ControlPanelGetSSHCAPublicKeyResponse:
3808    '''
3809         ControlPanelGetSSHCAPublicKeyResponse represents a request for an
3810     organization's SSH Certificate Authority public key.
3811    '''
3812    __slots__ = [
3813        'meta',
3814        'public_key',
3815        'rate_limit',
3816    ]
3817
3818    def __init__(
3819        self,
3820        meta=None,
3821        public_key=None,
3822        rate_limit=None,
3823    ):
3824        self.meta = meta if meta is not None else None
3825        '''
3826         Reserved for future use.
3827        '''
3828        self.public_key = public_key if public_key is not None else ''
3829        '''
3830         The public key of the SSH Certificate Authority, in OpenSSH RSA public
3831         key format.
3832        '''
3833        self.rate_limit = rate_limit if rate_limit is not None else None
3834        '''
3835         Rate limit information.
3836        '''
3837
3838    def __repr__(self):
3839        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
3840            'meta: ' + repr(self.meta) + ' ' +\
3841            'public_key: ' + repr(self.public_key) + ' ' +\
3842            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
3843            '>'
3844
3845    def to_dict(self):
3846        return {
3847            'meta': self.meta,
3848            'public_key': self.public_key,
3849            'rate_limit': self.rate_limit,
3850        }
3851
3852    @classmethod
3853    def from_dict(cls, d):
3854        return cls(
3855            meta=d.get('meta'),
3856            public_key=d.get('public_key'),
3857            rate_limit=d.get('rate_limit'),
3858        )

ControlPanelGetSSHCAPublicKeyResponse represents a request for an organization's SSH Certificate Authority public key.

ControlPanelGetSSHCAPublicKeyResponse(meta=None, public_key=None, rate_limit=None)
3818    def __init__(
3819        self,
3820        meta=None,
3821        public_key=None,
3822        rate_limit=None,
3823    ):
3824        self.meta = meta if meta is not None else None
3825        '''
3826         Reserved for future use.
3827        '''
3828        self.public_key = public_key if public_key is not None else ''
3829        '''
3830         The public key of the SSH Certificate Authority, in OpenSSH RSA public
3831         key format.
3832        '''
3833        self.rate_limit = rate_limit if rate_limit is not None else None
3834        '''
3835         Rate limit information.
3836        '''
meta

Reserved for future use.

public_key

The public key of the SSH Certificate Authority, in OpenSSH RSA public key format.

rate_limit

Rate limit information.

def to_dict(self)
3845    def to_dict(self):
3846        return {
3847            'meta': self.meta,
3848            'public_key': self.public_key,
3849            'rate_limit': self.rate_limit,
3850        }
@classmethod
def from_dict(cls, d)
3852    @classmethod
3853    def from_dict(cls, d):
3854        return cls(
3855            meta=d.get('meta'),
3856            public_key=d.get('public_key'),
3857            rate_limit=d.get('rate_limit'),
3858        )
class ControlPanelVerifyJWTResponse:
3861class ControlPanelVerifyJWTResponse:
3862    '''
3863         ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
3864    '''
3865    __slots__ = [
3866        'meta',
3867        'rate_limit',
3868        'valid',
3869    ]
3870
3871    def __init__(
3872        self,
3873        meta=None,
3874        rate_limit=None,
3875        valid=None,
3876    ):
3877        self.meta = meta if meta is not None else None
3878        '''
3879         Reserved for future use.
3880        '''
3881        self.rate_limit = rate_limit if rate_limit is not None else None
3882        '''
3883         Rate limit information.
3884        '''
3885        self.valid = valid if valid is not None else False
3886        '''
3887         Reports if the given token is valid.
3888        '''
3889
3890    def __repr__(self):
3891        return '<sdm.ControlPanelVerifyJWTResponse ' + \
3892            'meta: ' + repr(self.meta) + ' ' +\
3893            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
3894            'valid: ' + repr(self.valid) + ' ' +\
3895            '>'
3896
3897    def to_dict(self):
3898        return {
3899            'meta': self.meta,
3900            'rate_limit': self.rate_limit,
3901            'valid': self.valid,
3902        }
3903
3904    @classmethod
3905    def from_dict(cls, d):
3906        return cls(
3907            meta=d.get('meta'),
3908            rate_limit=d.get('rate_limit'),
3909            valid=d.get('valid'),
3910        )

ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.

ControlPanelVerifyJWTResponse(meta=None, rate_limit=None, valid=None)
3871    def __init__(
3872        self,
3873        meta=None,
3874        rate_limit=None,
3875        valid=None,
3876    ):
3877        self.meta = meta if meta is not None else None
3878        '''
3879         Reserved for future use.
3880        '''
3881        self.rate_limit = rate_limit if rate_limit is not None else None
3882        '''
3883         Rate limit information.
3884        '''
3885        self.valid = valid if valid is not None else False
3886        '''
3887         Reports if the given token is valid.
3888        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

valid

Reports if the given token is valid.

def to_dict(self)
3897    def to_dict(self):
3898        return {
3899            'meta': self.meta,
3900            'rate_limit': self.rate_limit,
3901            'valid': self.valid,
3902        }
@classmethod
def from_dict(cls, d)
3904    @classmethod
3905    def from_dict(cls, d):
3906        return cls(
3907            meta=d.get('meta'),
3908            rate_limit=d.get('rate_limit'),
3909            valid=d.get('valid'),
3910        )
class CreateResponseMetadata:
3913class CreateResponseMetadata:
3914    '''
3915         CreateResponseMetadata is reserved for future use.
3916    '''
3917    __slots__ = []
3918
3919    def __init__(self, ):
3920        pass
3921
3922    def __repr__(self):
3923        return '<sdm.CreateResponseMetadata ' + \
3924            '>'
3925
3926    def to_dict(self):
3927        return {}
3928
3929    @classmethod
3930    def from_dict(cls, d):
3931        return cls()

CreateResponseMetadata is reserved for future use.

CreateResponseMetadata()
3919    def __init__(self, ):
3920        pass
def to_dict(self)
3926    def to_dict(self):
3927        return {}
@classmethod
def from_dict(cls, d)
3929    @classmethod
3930    def from_dict(cls, d):
3931        return cls()
class CyberarkConjurStore:
3934class CyberarkConjurStore:
3935    __slots__ = [
3936        'appurl',
3937        'id',
3938        'name',
3939        'tags',
3940    ]
3941
3942    def __init__(
3943        self,
3944        appurl=None,
3945        id=None,
3946        name=None,
3947        tags=None,
3948    ):
3949        self.appurl = appurl if appurl is not None else ''
3950        self.id = id if id is not None else ''
3951        '''
3952         Unique identifier of the SecretStore.
3953        '''
3954        self.name = name if name is not None else ''
3955        '''
3956         Unique human-readable name of the SecretStore.
3957        '''
3958        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3959        '''
3960         Tags is a map of key, value pairs.
3961        '''
3962
3963    def __repr__(self):
3964        return '<sdm.CyberarkConjurStore ' + \
3965            'appurl: ' + repr(self.appurl) + ' ' +\
3966            'id: ' + repr(self.id) + ' ' +\
3967            'name: ' + repr(self.name) + ' ' +\
3968            'tags: ' + repr(self.tags) + ' ' +\
3969            '>'
3970
3971    def to_dict(self):
3972        return {
3973            'appurl': self.appurl,
3974            'id': self.id,
3975            'name': self.name,
3976            'tags': self.tags,
3977        }
3978
3979    @classmethod
3980    def from_dict(cls, d):
3981        return cls(
3982            appurl=d.get('appurl'),
3983            id=d.get('id'),
3984            name=d.get('name'),
3985            tags=d.get('tags'),
3986        )
CyberarkConjurStore(appurl=None, id=None, name=None, tags=None)
3942    def __init__(
3943        self,
3944        appurl=None,
3945        id=None,
3946        name=None,
3947        tags=None,
3948    ):
3949        self.appurl = appurl if appurl is not None else ''
3950        self.id = id if id is not None else ''
3951        '''
3952         Unique identifier of the SecretStore.
3953        '''
3954        self.name = name if name is not None else ''
3955        '''
3956         Unique human-readable name of the SecretStore.
3957        '''
3958        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3959        '''
3960         Tags is a map of key, value pairs.
3961        '''
appurl
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

def to_dict(self)
3971    def to_dict(self):
3972        return {
3973            'appurl': self.appurl,
3974            'id': self.id,
3975            'name': self.name,
3976            'tags': self.tags,
3977        }
@classmethod
def from_dict(cls, d)
3979    @classmethod
3980    def from_dict(cls, d):
3981        return cls(
3982            appurl=d.get('appurl'),
3983            id=d.get('id'),
3984            name=d.get('name'),
3985            tags=d.get('tags'),
3986        )
class CyberarkPAMExperimentalStore:
3989class CyberarkPAMExperimentalStore:
3990    '''
3991    CyberarkPAMExperimentalStore is currently unstable, and its API may change, or it may be removed,
3992    without a major version bump.
3993    '''
3994    __slots__ = [
3995        'appurl',
3996        'id',
3997        'name',
3998        'tags',
3999    ]
4000
4001    def __init__(
4002        self,
4003        appurl=None,
4004        id=None,
4005        name=None,
4006        tags=None,
4007    ):
4008        self.appurl = appurl if appurl is not None else ''
4009        self.id = id if id is not None else ''
4010        '''
4011         Unique identifier of the SecretStore.
4012        '''
4013        self.name = name if name is not None else ''
4014        '''
4015         Unique human-readable name of the SecretStore.
4016        '''
4017        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4018        '''
4019         Tags is a map of key, value pairs.
4020        '''
4021
4022    def __repr__(self):
4023        return '<sdm.CyberarkPAMExperimentalStore ' + \
4024            'appurl: ' + repr(self.appurl) + ' ' +\
4025            'id: ' + repr(self.id) + ' ' +\
4026            'name: ' + repr(self.name) + ' ' +\
4027            'tags: ' + repr(self.tags) + ' ' +\
4028            '>'
4029
4030    def to_dict(self):
4031        return {
4032            'appurl': self.appurl,
4033            'id': self.id,
4034            'name': self.name,
4035            'tags': self.tags,
4036        }
4037
4038    @classmethod
4039    def from_dict(cls, d):
4040        return cls(
4041            appurl=d.get('appurl'),
4042            id=d.get('id'),
4043            name=d.get('name'),
4044            tags=d.get('tags'),
4045        )

CyberarkPAMExperimentalStore is currently unstable, and its API may change, or it may be removed, without a major version bump.

CyberarkPAMExperimentalStore(appurl=None, id=None, name=None, tags=None)
4001    def __init__(
4002        self,
4003        appurl=None,
4004        id=None,
4005        name=None,
4006        tags=None,
4007    ):
4008        self.appurl = appurl if appurl is not None else ''
4009        self.id = id if id is not None else ''
4010        '''
4011         Unique identifier of the SecretStore.
4012        '''
4013        self.name = name if name is not None else ''
4014        '''
4015         Unique human-readable name of the SecretStore.
4016        '''
4017        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4018        '''
4019         Tags is a map of key, value pairs.
4020        '''
appurl
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

def to_dict(self)
4030    def to_dict(self):
4031        return {
4032            'appurl': self.appurl,
4033            'id': self.id,
4034            'name': self.name,
4035            'tags': self.tags,
4036        }
@classmethod
def from_dict(cls, d)
4038    @classmethod
4039    def from_dict(cls, d):
4040        return cls(
4041            appurl=d.get('appurl'),
4042            id=d.get('id'),
4043            name=d.get('name'),
4044            tags=d.get('tags'),
4045        )
class CyberarkPAMStore:
4048class CyberarkPAMStore:
4049    __slots__ = [
4050        'appurl',
4051        'id',
4052        'name',
4053        'tags',
4054    ]
4055
4056    def __init__(
4057        self,
4058        appurl=None,
4059        id=None,
4060        name=None,
4061        tags=None,
4062    ):
4063        self.appurl = appurl if appurl is not None else ''
4064        self.id = id if id is not None else ''
4065        '''
4066         Unique identifier of the SecretStore.
4067        '''
4068        self.name = name if name is not None else ''
4069        '''
4070         Unique human-readable name of the SecretStore.
4071        '''
4072        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4073        '''
4074         Tags is a map of key, value pairs.
4075        '''
4076
4077    def __repr__(self):
4078        return '<sdm.CyberarkPAMStore ' + \
4079            'appurl: ' + repr(self.appurl) + ' ' +\
4080            'id: ' + repr(self.id) + ' ' +\
4081            'name: ' + repr(self.name) + ' ' +\
4082            'tags: ' + repr(self.tags) + ' ' +\
4083            '>'
4084
4085    def to_dict(self):
4086        return {
4087            'appurl': self.appurl,
4088            'id': self.id,
4089            'name': self.name,
4090            'tags': self.tags,
4091        }
4092
4093    @classmethod
4094    def from_dict(cls, d):
4095        return cls(
4096            appurl=d.get('appurl'),
4097            id=d.get('id'),
4098            name=d.get('name'),
4099            tags=d.get('tags'),
4100        )
CyberarkPAMStore(appurl=None, id=None, name=None, tags=None)
4056    def __init__(
4057        self,
4058        appurl=None,
4059        id=None,
4060        name=None,
4061        tags=None,
4062    ):
4063        self.appurl = appurl if appurl is not None else ''
4064        self.id = id if id is not None else ''
4065        '''
4066         Unique identifier of the SecretStore.
4067        '''
4068        self.name = name if name is not None else ''
4069        '''
4070         Unique human-readable name of the SecretStore.
4071        '''
4072        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4073        '''
4074         Tags is a map of key, value pairs.
4075        '''
appurl
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

def to_dict(self)
4085    def to_dict(self):
4086        return {
4087            'appurl': self.appurl,
4088            'id': self.id,
4089            'name': self.name,
4090            'tags': self.tags,
4091        }
@classmethod
def from_dict(cls, d)
4093    @classmethod
4094    def from_dict(cls, d):
4095        return cls(
4096            appurl=d.get('appurl'),
4097            id=d.get('id'),
4098            name=d.get('name'),
4099            tags=d.get('tags'),
4100        )
class DB2I:
4103class DB2I:
4104    __slots__ = [
4105        'bind_interface',
4106        'egress_filter',
4107        'healthy',
4108        'hostname',
4109        'id',
4110        'name',
4111        'password',
4112        'port',
4113        'port_override',
4114        'secret_store_id',
4115        'tags',
4116        'tls_required',
4117        'username',
4118    ]
4119
4120    def __init__(
4121        self,
4122        bind_interface=None,
4123        egress_filter=None,
4124        healthy=None,
4125        hostname=None,
4126        id=None,
4127        name=None,
4128        password=None,
4129        port=None,
4130        port_override=None,
4131        secret_store_id=None,
4132        tags=None,
4133        tls_required=None,
4134        username=None,
4135    ):
4136        self.bind_interface = bind_interface if bind_interface is not None else ''
4137        '''
4138         Bind interface
4139        '''
4140        self.egress_filter = egress_filter if egress_filter is not None else ''
4141        '''
4142         A filter applied to the routing logic to pin datasource to nodes.
4143        '''
4144        self.healthy = healthy if healthy is not None else False
4145        '''
4146         True if the datasource is reachable and the credentials are valid.
4147        '''
4148        self.hostname = hostname if hostname is not None else ''
4149        self.id = id if id is not None else ''
4150        '''
4151         Unique identifier of the Resource.
4152        '''
4153        self.name = name if name is not None else ''
4154        '''
4155         Unique human-readable name of the Resource.
4156        '''
4157        self.password = password if password is not None else ''
4158        self.port = port if port is not None else 0
4159        self.port_override = port_override if port_override is not None else 0
4160        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4161        '''
4162         ID of the secret store containing credentials for this resource, if any.
4163        '''
4164        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4165        '''
4166         Tags is a map of key, value pairs.
4167        '''
4168        self.tls_required = tls_required if tls_required is not None else False
4169        self.username = username if username is not None else ''
4170
4171    def __repr__(self):
4172        return '<sdm.DB2I ' + \
4173            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4174            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4175            'healthy: ' + repr(self.healthy) + ' ' +\
4176            'hostname: ' + repr(self.hostname) + ' ' +\
4177            'id: ' + repr(self.id) + ' ' +\
4178            'name: ' + repr(self.name) + ' ' +\
4179            'password: ' + repr(self.password) + ' ' +\
4180            'port: ' + repr(self.port) + ' ' +\
4181            'port_override: ' + repr(self.port_override) + ' ' +\
4182            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4183            'tags: ' + repr(self.tags) + ' ' +\
4184            'tls_required: ' + repr(self.tls_required) + ' ' +\
4185            'username: ' + repr(self.username) + ' ' +\
4186            '>'
4187
4188    def to_dict(self):
4189        return {
4190            'bind_interface': self.bind_interface,
4191            'egress_filter': self.egress_filter,
4192            'healthy': self.healthy,
4193            'hostname': self.hostname,
4194            'id': self.id,
4195            'name': self.name,
4196            'password': self.password,
4197            'port': self.port,
4198            'port_override': self.port_override,
4199            'secret_store_id': self.secret_store_id,
4200            'tags': self.tags,
4201            'tls_required': self.tls_required,
4202            'username': self.username,
4203        }
4204
4205    @classmethod
4206    def from_dict(cls, d):
4207        return cls(
4208            bind_interface=d.get('bind_interface'),
4209            egress_filter=d.get('egress_filter'),
4210            healthy=d.get('healthy'),
4211            hostname=d.get('hostname'),
4212            id=d.get('id'),
4213            name=d.get('name'),
4214            password=d.get('password'),
4215            port=d.get('port'),
4216            port_override=d.get('port_override'),
4217            secret_store_id=d.get('secret_store_id'),
4218            tags=d.get('tags'),
4219            tls_required=d.get('tls_required'),
4220            username=d.get('username'),
4221        )
DB2I( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
4120    def __init__(
4121        self,
4122        bind_interface=None,
4123        egress_filter=None,
4124        healthy=None,
4125        hostname=None,
4126        id=None,
4127        name=None,
4128        password=None,
4129        port=None,
4130        port_override=None,
4131        secret_store_id=None,
4132        tags=None,
4133        tls_required=None,
4134        username=None,
4135    ):
4136        self.bind_interface = bind_interface if bind_interface is not None else ''
4137        '''
4138         Bind interface
4139        '''
4140        self.egress_filter = egress_filter if egress_filter is not None else ''
4141        '''
4142         A filter applied to the routing logic to pin datasource to nodes.
4143        '''
4144        self.healthy = healthy if healthy is not None else False
4145        '''
4146         True if the datasource is reachable and the credentials are valid.
4147        '''
4148        self.hostname = hostname if hostname is not None else ''
4149        self.id = id if id is not None else ''
4150        '''
4151         Unique identifier of the Resource.
4152        '''
4153        self.name = name if name is not None else ''
4154        '''
4155         Unique human-readable name of the Resource.
4156        '''
4157        self.password = password if password is not None else ''
4158        self.port = port if port is not None else 0
4159        self.port_override = port_override if port_override is not None else 0
4160        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4161        '''
4162         ID of the secret store containing credentials for this resource, if any.
4163        '''
4164        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4165        '''
4166         Tags is a map of key, value pairs.
4167        '''
4168        self.tls_required = tls_required if tls_required is not None else False
4169        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
4188    def to_dict(self):
4189        return {
4190            'bind_interface': self.bind_interface,
4191            'egress_filter': self.egress_filter,
4192            'healthy': self.healthy,
4193            'hostname': self.hostname,
4194            'id': self.id,
4195            'name': self.name,
4196            'password': self.password,
4197            'port': self.port,
4198            'port_override': self.port_override,
4199            'secret_store_id': self.secret_store_id,
4200            'tags': self.tags,
4201            'tls_required': self.tls_required,
4202            'username': self.username,
4203        }
@classmethod
def from_dict(cls, d)
4205    @classmethod
4206    def from_dict(cls, d):
4207        return cls(
4208            bind_interface=d.get('bind_interface'),
4209            egress_filter=d.get('egress_filter'),
4210            healthy=d.get('healthy'),
4211            hostname=d.get('hostname'),
4212            id=d.get('id'),
4213            name=d.get('name'),
4214            password=d.get('password'),
4215            port=d.get('port'),
4216            port_override=d.get('port_override'),
4217            secret_store_id=d.get('secret_store_id'),
4218            tags=d.get('tags'),
4219            tls_required=d.get('tls_required'),
4220            username=d.get('username'),
4221        )
class DB2LUW:
4224class DB2LUW:
4225    __slots__ = [
4226        'bind_interface',
4227        'database',
4228        'egress_filter',
4229        'healthy',
4230        'hostname',
4231        'id',
4232        'name',
4233        'password',
4234        'port',
4235        'port_override',
4236        'secret_store_id',
4237        'tags',
4238        'username',
4239    ]
4240
4241    def __init__(
4242        self,
4243        bind_interface=None,
4244        database=None,
4245        egress_filter=None,
4246        healthy=None,
4247        hostname=None,
4248        id=None,
4249        name=None,
4250        password=None,
4251        port=None,
4252        port_override=None,
4253        secret_store_id=None,
4254        tags=None,
4255        username=None,
4256    ):
4257        self.bind_interface = bind_interface if bind_interface is not None else ''
4258        '''
4259         Bind interface
4260        '''
4261        self.database = database if database is not None else ''
4262        self.egress_filter = egress_filter if egress_filter is not None else ''
4263        '''
4264         A filter applied to the routing logic to pin datasource to nodes.
4265        '''
4266        self.healthy = healthy if healthy is not None else False
4267        '''
4268         True if the datasource is reachable and the credentials are valid.
4269        '''
4270        self.hostname = hostname if hostname is not None else ''
4271        self.id = id if id is not None else ''
4272        '''
4273         Unique identifier of the Resource.
4274        '''
4275        self.name = name if name is not None else ''
4276        '''
4277         Unique human-readable name of the Resource.
4278        '''
4279        self.password = password if password is not None else ''
4280        self.port = port if port is not None else 0
4281        self.port_override = port_override if port_override is not None else 0
4282        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4283        '''
4284         ID of the secret store containing credentials for this resource, if any.
4285        '''
4286        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4287        '''
4288         Tags is a map of key, value pairs.
4289        '''
4290        self.username = username if username is not None else ''
4291
4292    def __repr__(self):
4293        return '<sdm.DB2LUW ' + \
4294            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4295            'database: ' + repr(self.database) + ' ' +\
4296            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4297            'healthy: ' + repr(self.healthy) + ' ' +\
4298            'hostname: ' + repr(self.hostname) + ' ' +\
4299            'id: ' + repr(self.id) + ' ' +\
4300            'name: ' + repr(self.name) + ' ' +\
4301            'password: ' + repr(self.password) + ' ' +\
4302            'port: ' + repr(self.port) + ' ' +\
4303            'port_override: ' + repr(self.port_override) + ' ' +\
4304            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4305            'tags: ' + repr(self.tags) + ' ' +\
4306            'username: ' + repr(self.username) + ' ' +\
4307            '>'
4308
4309    def to_dict(self):
4310        return {
4311            'bind_interface': self.bind_interface,
4312            'database': self.database,
4313            'egress_filter': self.egress_filter,
4314            'healthy': self.healthy,
4315            'hostname': self.hostname,
4316            'id': self.id,
4317            'name': self.name,
4318            'password': self.password,
4319            'port': self.port,
4320            'port_override': self.port_override,
4321            'secret_store_id': self.secret_store_id,
4322            'tags': self.tags,
4323            'username': self.username,
4324        }
4325
4326    @classmethod
4327    def from_dict(cls, d):
4328        return cls(
4329            bind_interface=d.get('bind_interface'),
4330            database=d.get('database'),
4331            egress_filter=d.get('egress_filter'),
4332            healthy=d.get('healthy'),
4333            hostname=d.get('hostname'),
4334            id=d.get('id'),
4335            name=d.get('name'),
4336            password=d.get('password'),
4337            port=d.get('port'),
4338            port_override=d.get('port_override'),
4339            secret_store_id=d.get('secret_store_id'),
4340            tags=d.get('tags'),
4341            username=d.get('username'),
4342        )
DB2LUW( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4241    def __init__(
4242        self,
4243        bind_interface=None,
4244        database=None,
4245        egress_filter=None,
4246        healthy=None,
4247        hostname=None,
4248        id=None,
4249        name=None,
4250        password=None,
4251        port=None,
4252        port_override=None,
4253        secret_store_id=None,
4254        tags=None,
4255        username=None,
4256    ):
4257        self.bind_interface = bind_interface if bind_interface is not None else ''
4258        '''
4259         Bind interface
4260        '''
4261        self.database = database if database is not None else ''
4262        self.egress_filter = egress_filter if egress_filter is not None else ''
4263        '''
4264         A filter applied to the routing logic to pin datasource to nodes.
4265        '''
4266        self.healthy = healthy if healthy is not None else False
4267        '''
4268         True if the datasource is reachable and the credentials are valid.
4269        '''
4270        self.hostname = hostname if hostname is not None else ''
4271        self.id = id if id is not None else ''
4272        '''
4273         Unique identifier of the Resource.
4274        '''
4275        self.name = name if name is not None else ''
4276        '''
4277         Unique human-readable name of the Resource.
4278        '''
4279        self.password = password if password is not None else ''
4280        self.port = port if port is not None else 0
4281        self.port_override = port_override if port_override is not None else 0
4282        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4283        '''
4284         ID of the secret store containing credentials for this resource, if any.
4285        '''
4286        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4287        '''
4288         Tags is a map of key, value pairs.
4289        '''
4290        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4309    def to_dict(self):
4310        return {
4311            'bind_interface': self.bind_interface,
4312            'database': self.database,
4313            'egress_filter': self.egress_filter,
4314            'healthy': self.healthy,
4315            'hostname': self.hostname,
4316            'id': self.id,
4317            'name': self.name,
4318            'password': self.password,
4319            'port': self.port,
4320            'port_override': self.port_override,
4321            'secret_store_id': self.secret_store_id,
4322            'tags': self.tags,
4323            'username': self.username,
4324        }
@classmethod
def from_dict(cls, d)
4326    @classmethod
4327    def from_dict(cls, d):
4328        return cls(
4329            bind_interface=d.get('bind_interface'),
4330            database=d.get('database'),
4331            egress_filter=d.get('egress_filter'),
4332            healthy=d.get('healthy'),
4333            hostname=d.get('hostname'),
4334            id=d.get('id'),
4335            name=d.get('name'),
4336            password=d.get('password'),
4337            port=d.get('port'),
4338            port_override=d.get('port_override'),
4339            secret_store_id=d.get('secret_store_id'),
4340            tags=d.get('tags'),
4341            username=d.get('username'),
4342        )
class DeleteResponseMetadata:
4345class DeleteResponseMetadata:
4346    '''
4347         DeleteResponseMetadata is reserved for future use.
4348    '''
4349    __slots__ = []
4350
4351    def __init__(self, ):
4352        pass
4353
4354    def __repr__(self):
4355        return '<sdm.DeleteResponseMetadata ' + \
4356            '>'
4357
4358    def to_dict(self):
4359        return {}
4360
4361    @classmethod
4362    def from_dict(cls, d):
4363        return cls()

DeleteResponseMetadata is reserved for future use.

DeleteResponseMetadata()
4351    def __init__(self, ):
4352        pass
def to_dict(self)
4358    def to_dict(self):
4359        return {}
@classmethod
def from_dict(cls, d)
4361    @classmethod
4362    def from_dict(cls, d):
4363        return cls()
class DelineaStore:
4366class DelineaStore:
4367    '''
4368    DelineaStore is currently unstable, and its API may change, or it may be removed,
4369    without a major version bump.
4370    '''
4371    __slots__ = [
4372        'id',
4373        'name',
4374        'server_url',
4375        'tags',
4376        'tenant_name',
4377    ]
4378
4379    def __init__(
4380        self,
4381        id=None,
4382        name=None,
4383        server_url=None,
4384        tags=None,
4385        tenant_name=None,
4386    ):
4387        self.id = id if id is not None else ''
4388        '''
4389         Unique identifier of the SecretStore.
4390        '''
4391        self.name = name if name is not None else ''
4392        '''
4393         Unique human-readable name of the SecretStore.
4394        '''
4395        self.server_url = server_url if server_url is not None else ''
4396        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4397        '''
4398         Tags is a map of key, value pairs.
4399        '''
4400        self.tenant_name = tenant_name if tenant_name is not None else ''
4401
4402    def __repr__(self):
4403        return '<sdm.DelineaStore ' + \
4404            'id: ' + repr(self.id) + ' ' +\
4405            'name: ' + repr(self.name) + ' ' +\
4406            'server_url: ' + repr(self.server_url) + ' ' +\
4407            'tags: ' + repr(self.tags) + ' ' +\
4408            'tenant_name: ' + repr(self.tenant_name) + ' ' +\
4409            '>'
4410
4411    def to_dict(self):
4412        return {
4413            'id': self.id,
4414            'name': self.name,
4415            'server_url': self.server_url,
4416            'tags': self.tags,
4417            'tenant_name': self.tenant_name,
4418        }
4419
4420    @classmethod
4421    def from_dict(cls, d):
4422        return cls(
4423            id=d.get('id'),
4424            name=d.get('name'),
4425            server_url=d.get('server_url'),
4426            tags=d.get('tags'),
4427            tenant_name=d.get('tenant_name'),
4428        )

DelineaStore is currently unstable, and its API may change, or it may be removed, without a major version bump.

DelineaStore(id=None, name=None, server_url=None, tags=None, tenant_name=None)
4379    def __init__(
4380        self,
4381        id=None,
4382        name=None,
4383        server_url=None,
4384        tags=None,
4385        tenant_name=None,
4386    ):
4387        self.id = id if id is not None else ''
4388        '''
4389         Unique identifier of the SecretStore.
4390        '''
4391        self.name = name if name is not None else ''
4392        '''
4393         Unique human-readable name of the SecretStore.
4394        '''
4395        self.server_url = server_url if server_url is not None else ''
4396        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4397        '''
4398         Tags is a map of key, value pairs.
4399        '''
4400        self.tenant_name = tenant_name if tenant_name is not None else ''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

server_url
tags

Tags is a map of key, value pairs.

tenant_name
def to_dict(self)
4411    def to_dict(self):
4412        return {
4413            'id': self.id,
4414            'name': self.name,
4415            'server_url': self.server_url,
4416            'tags': self.tags,
4417            'tenant_name': self.tenant_name,
4418        }
@classmethod
def from_dict(cls, d)
4420    @classmethod
4421    def from_dict(cls, d):
4422        return cls(
4423            id=d.get('id'),
4424            name=d.get('name'),
4425            server_url=d.get('server_url'),
4426            tags=d.get('tags'),
4427            tenant_name=d.get('tenant_name'),
4428        )
class DocumentDBHost:
4431class DocumentDBHost:
4432    __slots__ = [
4433        'auth_database',
4434        'bind_interface',
4435        'egress_filter',
4436        'healthy',
4437        'hostname',
4438        'id',
4439        'name',
4440        'password',
4441        'port',
4442        'port_override',
4443        'secret_store_id',
4444        'tags',
4445        'username',
4446    ]
4447
4448    def __init__(
4449        self,
4450        auth_database=None,
4451        bind_interface=None,
4452        egress_filter=None,
4453        healthy=None,
4454        hostname=None,
4455        id=None,
4456        name=None,
4457        password=None,
4458        port=None,
4459        port_override=None,
4460        secret_store_id=None,
4461        tags=None,
4462        username=None,
4463    ):
4464        self.auth_database = auth_database if auth_database is not None else ''
4465        self.bind_interface = bind_interface if bind_interface is not None else ''
4466        '''
4467         Bind interface
4468        '''
4469        self.egress_filter = egress_filter if egress_filter is not None else ''
4470        '''
4471         A filter applied to the routing logic to pin datasource to nodes.
4472        '''
4473        self.healthy = healthy if healthy is not None else False
4474        '''
4475         True if the datasource is reachable and the credentials are valid.
4476        '''
4477        self.hostname = hostname if hostname is not None else ''
4478        self.id = id if id is not None else ''
4479        '''
4480         Unique identifier of the Resource.
4481        '''
4482        self.name = name if name is not None else ''
4483        '''
4484         Unique human-readable name of the Resource.
4485        '''
4486        self.password = password if password is not None else ''
4487        self.port = port if port is not None else 0
4488        self.port_override = port_override if port_override is not None else 0
4489        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4490        '''
4491         ID of the secret store containing credentials for this resource, if any.
4492        '''
4493        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4494        '''
4495         Tags is a map of key, value pairs.
4496        '''
4497        self.username = username if username is not None else ''
4498
4499    def __repr__(self):
4500        return '<sdm.DocumentDBHost ' + \
4501            'auth_database: ' + repr(self.auth_database) + ' ' +\
4502            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4503            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4504            'healthy: ' + repr(self.healthy) + ' ' +\
4505            'hostname: ' + repr(self.hostname) + ' ' +\
4506            'id: ' + repr(self.id) + ' ' +\
4507            'name: ' + repr(self.name) + ' ' +\
4508            'password: ' + repr(self.password) + ' ' +\
4509            'port: ' + repr(self.port) + ' ' +\
4510            'port_override: ' + repr(self.port_override) + ' ' +\
4511            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4512            'tags: ' + repr(self.tags) + ' ' +\
4513            'username: ' + repr(self.username) + ' ' +\
4514            '>'
4515
4516    def to_dict(self):
4517        return {
4518            'auth_database': self.auth_database,
4519            'bind_interface': self.bind_interface,
4520            'egress_filter': self.egress_filter,
4521            'healthy': self.healthy,
4522            'hostname': self.hostname,
4523            'id': self.id,
4524            'name': self.name,
4525            'password': self.password,
4526            'port': self.port,
4527            'port_override': self.port_override,
4528            'secret_store_id': self.secret_store_id,
4529            'tags': self.tags,
4530            'username': self.username,
4531        }
4532
4533    @classmethod
4534    def from_dict(cls, d):
4535        return cls(
4536            auth_database=d.get('auth_database'),
4537            bind_interface=d.get('bind_interface'),
4538            egress_filter=d.get('egress_filter'),
4539            healthy=d.get('healthy'),
4540            hostname=d.get('hostname'),
4541            id=d.get('id'),
4542            name=d.get('name'),
4543            password=d.get('password'),
4544            port=d.get('port'),
4545            port_override=d.get('port_override'),
4546            secret_store_id=d.get('secret_store_id'),
4547            tags=d.get('tags'),
4548            username=d.get('username'),
4549        )
DocumentDBHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4448    def __init__(
4449        self,
4450        auth_database=None,
4451        bind_interface=None,
4452        egress_filter=None,
4453        healthy=None,
4454        hostname=None,
4455        id=None,
4456        name=None,
4457        password=None,
4458        port=None,
4459        port_override=None,
4460        secret_store_id=None,
4461        tags=None,
4462        username=None,
4463    ):
4464        self.auth_database = auth_database if auth_database is not None else ''
4465        self.bind_interface = bind_interface if bind_interface is not None else ''
4466        '''
4467         Bind interface
4468        '''
4469        self.egress_filter = egress_filter if egress_filter is not None else ''
4470        '''
4471         A filter applied to the routing logic to pin datasource to nodes.
4472        '''
4473        self.healthy = healthy if healthy is not None else False
4474        '''
4475         True if the datasource is reachable and the credentials are valid.
4476        '''
4477        self.hostname = hostname if hostname is not None else ''
4478        self.id = id if id is not None else ''
4479        '''
4480         Unique identifier of the Resource.
4481        '''
4482        self.name = name if name is not None else ''
4483        '''
4484         Unique human-readable name of the Resource.
4485        '''
4486        self.password = password if password is not None else ''
4487        self.port = port if port is not None else 0
4488        self.port_override = port_override if port_override is not None else 0
4489        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4490        '''
4491         ID of the secret store containing credentials for this resource, if any.
4492        '''
4493        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4494        '''
4495         Tags is a map of key, value pairs.
4496        '''
4497        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4516    def to_dict(self):
4517        return {
4518            'auth_database': self.auth_database,
4519            'bind_interface': self.bind_interface,
4520            'egress_filter': self.egress_filter,
4521            'healthy': self.healthy,
4522            'hostname': self.hostname,
4523            'id': self.id,
4524            'name': self.name,
4525            'password': self.password,
4526            'port': self.port,
4527            'port_override': self.port_override,
4528            'secret_store_id': self.secret_store_id,
4529            'tags': self.tags,
4530            'username': self.username,
4531        }
@classmethod
def from_dict(cls, d)
4533    @classmethod
4534    def from_dict(cls, d):
4535        return cls(
4536            auth_database=d.get('auth_database'),
4537            bind_interface=d.get('bind_interface'),
4538            egress_filter=d.get('egress_filter'),
4539            healthy=d.get('healthy'),
4540            hostname=d.get('hostname'),
4541            id=d.get('id'),
4542            name=d.get('name'),
4543            password=d.get('password'),
4544            port=d.get('port'),
4545            port_override=d.get('port_override'),
4546            secret_store_id=d.get('secret_store_id'),
4547            tags=d.get('tags'),
4548            username=d.get('username'),
4549        )
class DocumentDBReplicaSet:
4552class DocumentDBReplicaSet:
4553    __slots__ = [
4554        'auth_database',
4555        'bind_interface',
4556        'connect_to_replica',
4557        'egress_filter',
4558        'healthy',
4559        'hostname',
4560        'id',
4561        'name',
4562        'password',
4563        'port_override',
4564        'replica_set',
4565        'secret_store_id',
4566        'tags',
4567        'username',
4568    ]
4569
4570    def __init__(
4571        self,
4572        auth_database=None,
4573        bind_interface=None,
4574        connect_to_replica=None,
4575        egress_filter=None,
4576        healthy=None,
4577        hostname=None,
4578        id=None,
4579        name=None,
4580        password=None,
4581        port_override=None,
4582        replica_set=None,
4583        secret_store_id=None,
4584        tags=None,
4585        username=None,
4586    ):
4587        self.auth_database = auth_database if auth_database is not None else ''
4588        self.bind_interface = bind_interface if bind_interface is not None else ''
4589        '''
4590         Bind interface
4591        '''
4592        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
4593        self.egress_filter = egress_filter if egress_filter is not None else ''
4594        '''
4595         A filter applied to the routing logic to pin datasource to nodes.
4596        '''
4597        self.healthy = healthy if healthy is not None else False
4598        '''
4599         True if the datasource is reachable and the credentials are valid.
4600        '''
4601        self.hostname = hostname if hostname is not None else ''
4602        '''
4603         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
4604        '''
4605        self.id = id if id is not None else ''
4606        '''
4607         Unique identifier of the Resource.
4608        '''
4609        self.name = name if name is not None else ''
4610        '''
4611         Unique human-readable name of the Resource.
4612        '''
4613        self.password = password if password is not None else ''
4614        self.port_override = port_override if port_override is not None else 0
4615        self.replica_set = replica_set if replica_set is not None else ''
4616        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4617        '''
4618         ID of the secret store containing credentials for this resource, if any.
4619        '''
4620        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4621        '''
4622         Tags is a map of key, value pairs.
4623        '''
4624        self.username = username if username is not None else ''
4625
4626    def __repr__(self):
4627        return '<sdm.DocumentDBReplicaSet ' + \
4628            'auth_database: ' + repr(self.auth_database) + ' ' +\
4629            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4630            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
4631            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4632            'healthy: ' + repr(self.healthy) + ' ' +\
4633            'hostname: ' + repr(self.hostname) + ' ' +\
4634            'id: ' + repr(self.id) + ' ' +\
4635            'name: ' + repr(self.name) + ' ' +\
4636            'password: ' + repr(self.password) + ' ' +\
4637            'port_override: ' + repr(self.port_override) + ' ' +\
4638            'replica_set: ' + repr(self.replica_set) + ' ' +\
4639            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4640            'tags: ' + repr(self.tags) + ' ' +\
4641            'username: ' + repr(self.username) + ' ' +\
4642            '>'
4643
4644    def to_dict(self):
4645        return {
4646            'auth_database': self.auth_database,
4647            'bind_interface': self.bind_interface,
4648            'connect_to_replica': self.connect_to_replica,
4649            'egress_filter': self.egress_filter,
4650            'healthy': self.healthy,
4651            'hostname': self.hostname,
4652            'id': self.id,
4653            'name': self.name,
4654            'password': self.password,
4655            'port_override': self.port_override,
4656            'replica_set': self.replica_set,
4657            'secret_store_id': self.secret_store_id,
4658            'tags': self.tags,
4659            'username': self.username,
4660        }
4661
4662    @classmethod
4663    def from_dict(cls, d):
4664        return cls(
4665            auth_database=d.get('auth_database'),
4666            bind_interface=d.get('bind_interface'),
4667            connect_to_replica=d.get('connect_to_replica'),
4668            egress_filter=d.get('egress_filter'),
4669            healthy=d.get('healthy'),
4670            hostname=d.get('hostname'),
4671            id=d.get('id'),
4672            name=d.get('name'),
4673            password=d.get('password'),
4674            port_override=d.get('port_override'),
4675            replica_set=d.get('replica_set'),
4676            secret_store_id=d.get('secret_store_id'),
4677            tags=d.get('tags'),
4678            username=d.get('username'),
4679        )
DocumentDBReplicaSet( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, username=None)
4570    def __init__(
4571        self,
4572        auth_database=None,
4573        bind_interface=None,
4574        connect_to_replica=None,
4575        egress_filter=None,
4576        healthy=None,
4577        hostname=None,
4578        id=None,
4579        name=None,
4580        password=None,
4581        port_override=None,
4582        replica_set=None,
4583        secret_store_id=None,
4584        tags=None,
4585        username=None,
4586    ):
4587        self.auth_database = auth_database if auth_database is not None else ''
4588        self.bind_interface = bind_interface if bind_interface is not None else ''
4589        '''
4590         Bind interface
4591        '''
4592        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
4593        self.egress_filter = egress_filter if egress_filter is not None else ''
4594        '''
4595         A filter applied to the routing logic to pin datasource to nodes.
4596        '''
4597        self.healthy = healthy if healthy is not None else False
4598        '''
4599         True if the datasource is reachable and the credentials are valid.
4600        '''
4601        self.hostname = hostname if hostname is not None else ''
4602        '''
4603         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
4604        '''
4605        self.id = id if id is not None else ''
4606        '''
4607         Unique identifier of the Resource.
4608        '''
4609        self.name = name if name is not None else ''
4610        '''
4611         Unique human-readable name of the Resource.
4612        '''
4613        self.password = password if password is not None else ''
4614        self.port_override = port_override if port_override is not None else 0
4615        self.replica_set = replica_set if replica_set is not None else ''
4616        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4617        '''
4618         ID of the secret store containing credentials for this resource, if any.
4619        '''
4620        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4621        '''
4622         Tags is a map of key, value pairs.
4623        '''
4624        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname

Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4644    def to_dict(self):
4645        return {
4646            'auth_database': self.auth_database,
4647            'bind_interface': self.bind_interface,
4648            'connect_to_replica': self.connect_to_replica,
4649            'egress_filter': self.egress_filter,
4650            'healthy': self.healthy,
4651            'hostname': self.hostname,
4652            'id': self.id,
4653            'name': self.name,
4654            'password': self.password,
4655            'port_override': self.port_override,
4656            'replica_set': self.replica_set,
4657            'secret_store_id': self.secret_store_id,
4658            'tags': self.tags,
4659            'username': self.username,
4660        }
@classmethod
def from_dict(cls, d)
4662    @classmethod
4663    def from_dict(cls, d):
4664        return cls(
4665            auth_database=d.get('auth_database'),
4666            bind_interface=d.get('bind_interface'),
4667            connect_to_replica=d.get('connect_to_replica'),
4668            egress_filter=d.get('egress_filter'),
4669            healthy=d.get('healthy'),
4670            hostname=d.get('hostname'),
4671            id=d.get('id'),
4672            name=d.get('name'),
4673            password=d.get('password'),
4674            port_override=d.get('port_override'),
4675            replica_set=d.get('replica_set'),
4676            secret_store_id=d.get('secret_store_id'),
4677            tags=d.get('tags'),
4678            username=d.get('username'),
4679        )
class Druid:
4682class Druid:
4683    __slots__ = [
4684        'bind_interface',
4685        'egress_filter',
4686        'healthy',
4687        'hostname',
4688        'id',
4689        'name',
4690        'password',
4691        'port',
4692        'port_override',
4693        'secret_store_id',
4694        'tags',
4695        'username',
4696    ]
4697
4698    def __init__(
4699        self,
4700        bind_interface=None,
4701        egress_filter=None,
4702        healthy=None,
4703        hostname=None,
4704        id=None,
4705        name=None,
4706        password=None,
4707        port=None,
4708        port_override=None,
4709        secret_store_id=None,
4710        tags=None,
4711        username=None,
4712    ):
4713        self.bind_interface = bind_interface if bind_interface is not None else ''
4714        '''
4715         Bind interface
4716        '''
4717        self.egress_filter = egress_filter if egress_filter is not None else ''
4718        '''
4719         A filter applied to the routing logic to pin datasource to nodes.
4720        '''
4721        self.healthy = healthy if healthy is not None else False
4722        '''
4723         True if the datasource is reachable and the credentials are valid.
4724        '''
4725        self.hostname = hostname if hostname is not None else ''
4726        self.id = id if id is not None else ''
4727        '''
4728         Unique identifier of the Resource.
4729        '''
4730        self.name = name if name is not None else ''
4731        '''
4732         Unique human-readable name of the Resource.
4733        '''
4734        self.password = password if password is not None else ''
4735        self.port = port if port is not None else 0
4736        self.port_override = port_override if port_override is not None else 0
4737        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4738        '''
4739         ID of the secret store containing credentials for this resource, if any.
4740        '''
4741        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4742        '''
4743         Tags is a map of key, value pairs.
4744        '''
4745        self.username = username if username is not None else ''
4746
4747    def __repr__(self):
4748        return '<sdm.Druid ' + \
4749            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4750            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4751            'healthy: ' + repr(self.healthy) + ' ' +\
4752            'hostname: ' + repr(self.hostname) + ' ' +\
4753            'id: ' + repr(self.id) + ' ' +\
4754            'name: ' + repr(self.name) + ' ' +\
4755            'password: ' + repr(self.password) + ' ' +\
4756            'port: ' + repr(self.port) + ' ' +\
4757            'port_override: ' + repr(self.port_override) + ' ' +\
4758            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4759            'tags: ' + repr(self.tags) + ' ' +\
4760            'username: ' + repr(self.username) + ' ' +\
4761            '>'
4762
4763    def to_dict(self):
4764        return {
4765            'bind_interface': self.bind_interface,
4766            'egress_filter': self.egress_filter,
4767            'healthy': self.healthy,
4768            'hostname': self.hostname,
4769            'id': self.id,
4770            'name': self.name,
4771            'password': self.password,
4772            'port': self.port,
4773            'port_override': self.port_override,
4774            'secret_store_id': self.secret_store_id,
4775            'tags': self.tags,
4776            'username': self.username,
4777        }
4778
4779    @classmethod
4780    def from_dict(cls, d):
4781        return cls(
4782            bind_interface=d.get('bind_interface'),
4783            egress_filter=d.get('egress_filter'),
4784            healthy=d.get('healthy'),
4785            hostname=d.get('hostname'),
4786            id=d.get('id'),
4787            name=d.get('name'),
4788            password=d.get('password'),
4789            port=d.get('port'),
4790            port_override=d.get('port_override'),
4791            secret_store_id=d.get('secret_store_id'),
4792            tags=d.get('tags'),
4793            username=d.get('username'),
4794        )
Druid( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4698    def __init__(
4699        self,
4700        bind_interface=None,
4701        egress_filter=None,
4702        healthy=None,
4703        hostname=None,
4704        id=None,
4705        name=None,
4706        password=None,
4707        port=None,
4708        port_override=None,
4709        secret_store_id=None,
4710        tags=None,
4711        username=None,
4712    ):
4713        self.bind_interface = bind_interface if bind_interface is not None else ''
4714        '''
4715         Bind interface
4716        '''
4717        self.egress_filter = egress_filter if egress_filter is not None else ''
4718        '''
4719         A filter applied to the routing logic to pin datasource to nodes.
4720        '''
4721        self.healthy = healthy if healthy is not None else False
4722        '''
4723         True if the datasource is reachable and the credentials are valid.
4724        '''
4725        self.hostname = hostname if hostname is not None else ''
4726        self.id = id if id is not None else ''
4727        '''
4728         Unique identifier of the Resource.
4729        '''
4730        self.name = name if name is not None else ''
4731        '''
4732         Unique human-readable name of the Resource.
4733        '''
4734        self.password = password if password is not None else ''
4735        self.port = port if port is not None else 0
4736        self.port_override = port_override if port_override is not None else 0
4737        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4738        '''
4739         ID of the secret store containing credentials for this resource, if any.
4740        '''
4741        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4742        '''
4743         Tags is a map of key, value pairs.
4744        '''
4745        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4763    def to_dict(self):
4764        return {
4765            'bind_interface': self.bind_interface,
4766            'egress_filter': self.egress_filter,
4767            'healthy': self.healthy,
4768            'hostname': self.hostname,
4769            'id': self.id,
4770            'name': self.name,
4771            'password': self.password,
4772            'port': self.port,
4773            'port_override': self.port_override,
4774            'secret_store_id': self.secret_store_id,
4775            'tags': self.tags,
4776            'username': self.username,
4777        }
@classmethod
def from_dict(cls, d)
4779    @classmethod
4780    def from_dict(cls, d):
4781        return cls(
4782            bind_interface=d.get('bind_interface'),
4783            egress_filter=d.get('egress_filter'),
4784            healthy=d.get('healthy'),
4785            hostname=d.get('hostname'),
4786            id=d.get('id'),
4787            name=d.get('name'),
4788            password=d.get('password'),
4789            port=d.get('port'),
4790            port_override=d.get('port_override'),
4791            secret_store_id=d.get('secret_store_id'),
4792            tags=d.get('tags'),
4793            username=d.get('username'),
4794        )
class DynamoDB:
4797class DynamoDB:
4798    __slots__ = [
4799        'access_key',
4800        'bind_interface',
4801        'egress_filter',
4802        'endpoint',
4803        'healthy',
4804        'id',
4805        'name',
4806        'port_override',
4807        'region',
4808        'role_arn',
4809        'role_external_id',
4810        'secret_access_key',
4811        'secret_store_id',
4812        'tags',
4813    ]
4814
4815    def __init__(
4816        self,
4817        access_key=None,
4818        bind_interface=None,
4819        egress_filter=None,
4820        endpoint=None,
4821        healthy=None,
4822        id=None,
4823        name=None,
4824        port_override=None,
4825        region=None,
4826        role_arn=None,
4827        role_external_id=None,
4828        secret_access_key=None,
4829        secret_store_id=None,
4830        tags=None,
4831    ):
4832        self.access_key = access_key if access_key is not None else ''
4833        self.bind_interface = bind_interface if bind_interface is not None else ''
4834        '''
4835         Bind interface
4836        '''
4837        self.egress_filter = egress_filter if egress_filter is not None else ''
4838        '''
4839         A filter applied to the routing logic to pin datasource to nodes.
4840        '''
4841        self.endpoint = endpoint if endpoint is not None else ''
4842        self.healthy = healthy if healthy is not None else False
4843        '''
4844         True if the datasource is reachable and the credentials are valid.
4845        '''
4846        self.id = id if id is not None else ''
4847        '''
4848         Unique identifier of the Resource.
4849        '''
4850        self.name = name if name is not None else ''
4851        '''
4852         Unique human-readable name of the Resource.
4853        '''
4854        self.port_override = port_override if port_override is not None else 0
4855        self.region = region if region is not None else ''
4856        self.role_arn = role_arn if role_arn is not None else ''
4857        self.role_external_id = role_external_id if role_external_id is not None else ''
4858        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
4859        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4860        '''
4861         ID of the secret store containing credentials for this resource, if any.
4862        '''
4863        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4864        '''
4865         Tags is a map of key, value pairs.
4866        '''
4867
4868    def __repr__(self):
4869        return '<sdm.DynamoDB ' + \
4870            'access_key: ' + repr(self.access_key) + ' ' +\
4871            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4872            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4873            'endpoint: ' + repr(self.endpoint) + ' ' +\
4874            'healthy: ' + repr(self.healthy) + ' ' +\
4875            'id: ' + repr(self.id) + ' ' +\
4876            'name: ' + repr(self.name) + ' ' +\
4877            'port_override: ' + repr(self.port_override) + ' ' +\
4878            'region: ' + repr(self.region) + ' ' +\
4879            'role_arn: ' + repr(self.role_arn) + ' ' +\
4880            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
4881            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
4882            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4883            'tags: ' + repr(self.tags) + ' ' +\
4884            '>'
4885
4886    def to_dict(self):
4887        return {
4888            'access_key': self.access_key,
4889            'bind_interface': self.bind_interface,
4890            'egress_filter': self.egress_filter,
4891            'endpoint': self.endpoint,
4892            'healthy': self.healthy,
4893            'id': self.id,
4894            'name': self.name,
4895            'port_override': self.port_override,
4896            'region': self.region,
4897            'role_arn': self.role_arn,
4898            'role_external_id': self.role_external_id,
4899            'secret_access_key': self.secret_access_key,
4900            'secret_store_id': self.secret_store_id,
4901            'tags': self.tags,
4902        }
4903
4904    @classmethod
4905    def from_dict(cls, d):
4906        return cls(
4907            access_key=d.get('access_key'),
4908            bind_interface=d.get('bind_interface'),
4909            egress_filter=d.get('egress_filter'),
4910            endpoint=d.get('endpoint'),
4911            healthy=d.get('healthy'),
4912            id=d.get('id'),
4913            name=d.get('name'),
4914            port_override=d.get('port_override'),
4915            region=d.get('region'),
4916            role_arn=d.get('role_arn'),
4917            role_external_id=d.get('role_external_id'),
4918            secret_access_key=d.get('secret_access_key'),
4919            secret_store_id=d.get('secret_store_id'),
4920            tags=d.get('tags'),
4921        )
DynamoDB( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
4815    def __init__(
4816        self,
4817        access_key=None,
4818        bind_interface=None,
4819        egress_filter=None,
4820        endpoint=None,
4821        healthy=None,
4822        id=None,
4823        name=None,
4824        port_override=None,
4825        region=None,
4826        role_arn=None,
4827        role_external_id=None,
4828        secret_access_key=None,
4829        secret_store_id=None,
4830        tags=None,
4831    ):
4832        self.access_key = access_key if access_key is not None else ''
4833        self.bind_interface = bind_interface if bind_interface is not None else ''
4834        '''
4835         Bind interface
4836        '''
4837        self.egress_filter = egress_filter if egress_filter is not None else ''
4838        '''
4839         A filter applied to the routing logic to pin datasource to nodes.
4840        '''
4841        self.endpoint = endpoint if endpoint is not None else ''
4842        self.healthy = healthy if healthy is not None else False
4843        '''
4844         True if the datasource is reachable and the credentials are valid.
4845        '''
4846        self.id = id if id is not None else ''
4847        '''
4848         Unique identifier of the Resource.
4849        '''
4850        self.name = name if name is not None else ''
4851        '''
4852         Unique human-readable name of the Resource.
4853        '''
4854        self.port_override = port_override if port_override is not None else 0
4855        self.region = region if region is not None else ''
4856        self.role_arn = role_arn if role_arn is not None else ''
4857        self.role_external_id = role_external_id if role_external_id is not None else ''
4858        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
4859        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4860        '''
4861         ID of the secret store containing credentials for this resource, if any.
4862        '''
4863        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4864        '''
4865         Tags is a map of key, value pairs.
4866        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
4886    def to_dict(self):
4887        return {
4888            'access_key': self.access_key,
4889            'bind_interface': self.bind_interface,
4890            'egress_filter': self.egress_filter,
4891            'endpoint': self.endpoint,
4892            'healthy': self.healthy,
4893            'id': self.id,
4894            'name': self.name,
4895            'port_override': self.port_override,
4896            'region': self.region,
4897            'role_arn': self.role_arn,
4898            'role_external_id': self.role_external_id,
4899            'secret_access_key': self.secret_access_key,
4900            'secret_store_id': self.secret_store_id,
4901            'tags': self.tags,
4902        }
@classmethod
def from_dict(cls, d)
4904    @classmethod
4905    def from_dict(cls, d):
4906        return cls(
4907            access_key=d.get('access_key'),
4908            bind_interface=d.get('bind_interface'),
4909            egress_filter=d.get('egress_filter'),
4910            endpoint=d.get('endpoint'),
4911            healthy=d.get('healthy'),
4912            id=d.get('id'),
4913            name=d.get('name'),
4914            port_override=d.get('port_override'),
4915            region=d.get('region'),
4916            role_arn=d.get('role_arn'),
4917            role_external_id=d.get('role_external_id'),
4918            secret_access_key=d.get('secret_access_key'),
4919            secret_store_id=d.get('secret_store_id'),
4920            tags=d.get('tags'),
4921        )
class Elastic:
4924class Elastic:
4925    __slots__ = [
4926        'bind_interface',
4927        'egress_filter',
4928        'healthy',
4929        'hostname',
4930        'id',
4931        'name',
4932        'password',
4933        'port',
4934        'port_override',
4935        'secret_store_id',
4936        'tags',
4937        'tls_required',
4938        'username',
4939    ]
4940
4941    def __init__(
4942        self,
4943        bind_interface=None,
4944        egress_filter=None,
4945        healthy=None,
4946        hostname=None,
4947        id=None,
4948        name=None,
4949        password=None,
4950        port=None,
4951        port_override=None,
4952        secret_store_id=None,
4953        tags=None,
4954        tls_required=None,
4955        username=None,
4956    ):
4957        self.bind_interface = bind_interface if bind_interface is not None else ''
4958        '''
4959         Bind interface
4960        '''
4961        self.egress_filter = egress_filter if egress_filter is not None else ''
4962        '''
4963         A filter applied to the routing logic to pin datasource to nodes.
4964        '''
4965        self.healthy = healthy if healthy is not None else False
4966        '''
4967         True if the datasource is reachable and the credentials are valid.
4968        '''
4969        self.hostname = hostname if hostname is not None else ''
4970        self.id = id if id is not None else ''
4971        '''
4972         Unique identifier of the Resource.
4973        '''
4974        self.name = name if name is not None else ''
4975        '''
4976         Unique human-readable name of the Resource.
4977        '''
4978        self.password = password if password is not None else ''
4979        self.port = port if port is not None else 0
4980        self.port_override = port_override if port_override is not None else 0
4981        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4982        '''
4983         ID of the secret store containing credentials for this resource, if any.
4984        '''
4985        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4986        '''
4987         Tags is a map of key, value pairs.
4988        '''
4989        self.tls_required = tls_required if tls_required is not None else False
4990        self.username = username if username is not None else ''
4991
4992    def __repr__(self):
4993        return '<sdm.Elastic ' + \
4994            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4995            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4996            'healthy: ' + repr(self.healthy) + ' ' +\
4997            'hostname: ' + repr(self.hostname) + ' ' +\
4998            'id: ' + repr(self.id) + ' ' +\
4999            'name: ' + repr(self.name) + ' ' +\
5000            'password: ' + repr(self.password) + ' ' +\
5001            'port: ' + repr(self.port) + ' ' +\
5002            'port_override: ' + repr(self.port_override) + ' ' +\
5003            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5004            'tags: ' + repr(self.tags) + ' ' +\
5005            'tls_required: ' + repr(self.tls_required) + ' ' +\
5006            'username: ' + repr(self.username) + ' ' +\
5007            '>'
5008
5009    def to_dict(self):
5010        return {
5011            'bind_interface': self.bind_interface,
5012            'egress_filter': self.egress_filter,
5013            'healthy': self.healthy,
5014            'hostname': self.hostname,
5015            'id': self.id,
5016            'name': self.name,
5017            'password': self.password,
5018            'port': self.port,
5019            'port_override': self.port_override,
5020            'secret_store_id': self.secret_store_id,
5021            'tags': self.tags,
5022            'tls_required': self.tls_required,
5023            'username': self.username,
5024        }
5025
5026    @classmethod
5027    def from_dict(cls, d):
5028        return cls(
5029            bind_interface=d.get('bind_interface'),
5030            egress_filter=d.get('egress_filter'),
5031            healthy=d.get('healthy'),
5032            hostname=d.get('hostname'),
5033            id=d.get('id'),
5034            name=d.get('name'),
5035            password=d.get('password'),
5036            port=d.get('port'),
5037            port_override=d.get('port_override'),
5038            secret_store_id=d.get('secret_store_id'),
5039            tags=d.get('tags'),
5040            tls_required=d.get('tls_required'),
5041            username=d.get('username'),
5042        )
Elastic( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
4941    def __init__(
4942        self,
4943        bind_interface=None,
4944        egress_filter=None,
4945        healthy=None,
4946        hostname=None,
4947        id=None,
4948        name=None,
4949        password=None,
4950        port=None,
4951        port_override=None,
4952        secret_store_id=None,
4953        tags=None,
4954        tls_required=None,
4955        username=None,
4956    ):
4957        self.bind_interface = bind_interface if bind_interface is not None else ''
4958        '''
4959         Bind interface
4960        '''
4961        self.egress_filter = egress_filter if egress_filter is not None else ''
4962        '''
4963         A filter applied to the routing logic to pin datasource to nodes.
4964        '''
4965        self.healthy = healthy if healthy is not None else False
4966        '''
4967         True if the datasource is reachable and the credentials are valid.
4968        '''
4969        self.hostname = hostname if hostname is not None else ''
4970        self.id = id if id is not None else ''
4971        '''
4972         Unique identifier of the Resource.
4973        '''
4974        self.name = name if name is not None else ''
4975        '''
4976         Unique human-readable name of the Resource.
4977        '''
4978        self.password = password if password is not None else ''
4979        self.port = port if port is not None else 0
4980        self.port_override = port_override if port_override is not None else 0
4981        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4982        '''
4983         ID of the secret store containing credentials for this resource, if any.
4984        '''
4985        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4986        '''
4987         Tags is a map of key, value pairs.
4988        '''
4989        self.tls_required = tls_required if tls_required is not None else False
4990        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
5009    def to_dict(self):
5010        return {
5011            'bind_interface': self.bind_interface,
5012            'egress_filter': self.egress_filter,
5013            'healthy': self.healthy,
5014            'hostname': self.hostname,
5015            'id': self.id,
5016            'name': self.name,
5017            'password': self.password,
5018            'port': self.port,
5019            'port_override': self.port_override,
5020            'secret_store_id': self.secret_store_id,
5021            'tags': self.tags,
5022            'tls_required': self.tls_required,
5023            'username': self.username,
5024        }
@classmethod
def from_dict(cls, d)
5026    @classmethod
5027    def from_dict(cls, d):
5028        return cls(
5029            bind_interface=d.get('bind_interface'),
5030            egress_filter=d.get('egress_filter'),
5031            healthy=d.get('healthy'),
5032            hostname=d.get('hostname'),
5033            id=d.get('id'),
5034            name=d.get('name'),
5035            password=d.get('password'),
5036            port=d.get('port'),
5037            port_override=d.get('port_override'),
5038            secret_store_id=d.get('secret_store_id'),
5039            tags=d.get('tags'),
5040            tls_required=d.get('tls_required'),
5041            username=d.get('username'),
5042        )
class ElasticacheRedis:
5045class ElasticacheRedis:
5046    __slots__ = [
5047        'bind_interface',
5048        'egress_filter',
5049        'healthy',
5050        'hostname',
5051        'id',
5052        'name',
5053        'password',
5054        'port',
5055        'port_override',
5056        'secret_store_id',
5057        'tags',
5058        'tls_required',
5059        'username',
5060    ]
5061
5062    def __init__(
5063        self,
5064        bind_interface=None,
5065        egress_filter=None,
5066        healthy=None,
5067        hostname=None,
5068        id=None,
5069        name=None,
5070        password=None,
5071        port=None,
5072        port_override=None,
5073        secret_store_id=None,
5074        tags=None,
5075        tls_required=None,
5076        username=None,
5077    ):
5078        self.bind_interface = bind_interface if bind_interface is not None else ''
5079        '''
5080         Bind interface
5081        '''
5082        self.egress_filter = egress_filter if egress_filter is not None else ''
5083        '''
5084         A filter applied to the routing logic to pin datasource to nodes.
5085        '''
5086        self.healthy = healthy if healthy is not None else False
5087        '''
5088         True if the datasource is reachable and the credentials are valid.
5089        '''
5090        self.hostname = hostname if hostname is not None else ''
5091        self.id = id if id is not None else ''
5092        '''
5093         Unique identifier of the Resource.
5094        '''
5095        self.name = name if name is not None else ''
5096        '''
5097         Unique human-readable name of the Resource.
5098        '''
5099        self.password = password if password is not None else ''
5100        self.port = port if port is not None else 0
5101        self.port_override = port_override if port_override is not None else 0
5102        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5103        '''
5104         ID of the secret store containing credentials for this resource, if any.
5105        '''
5106        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5107        '''
5108         Tags is a map of key, value pairs.
5109        '''
5110        self.tls_required = tls_required if tls_required is not None else False
5111        self.username = username if username is not None else ''
5112
5113    def __repr__(self):
5114        return '<sdm.ElasticacheRedis ' + \
5115            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5116            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5117            'healthy: ' + repr(self.healthy) + ' ' +\
5118            'hostname: ' + repr(self.hostname) + ' ' +\
5119            'id: ' + repr(self.id) + ' ' +\
5120            'name: ' + repr(self.name) + ' ' +\
5121            'password: ' + repr(self.password) + ' ' +\
5122            'port: ' + repr(self.port) + ' ' +\
5123            'port_override: ' + repr(self.port_override) + ' ' +\
5124            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5125            'tags: ' + repr(self.tags) + ' ' +\
5126            'tls_required: ' + repr(self.tls_required) + ' ' +\
5127            'username: ' + repr(self.username) + ' ' +\
5128            '>'
5129
5130    def to_dict(self):
5131        return {
5132            'bind_interface': self.bind_interface,
5133            'egress_filter': self.egress_filter,
5134            'healthy': self.healthy,
5135            'hostname': self.hostname,
5136            'id': self.id,
5137            'name': self.name,
5138            'password': self.password,
5139            'port': self.port,
5140            'port_override': self.port_override,
5141            'secret_store_id': self.secret_store_id,
5142            'tags': self.tags,
5143            'tls_required': self.tls_required,
5144            'username': self.username,
5145        }
5146
5147    @classmethod
5148    def from_dict(cls, d):
5149        return cls(
5150            bind_interface=d.get('bind_interface'),
5151            egress_filter=d.get('egress_filter'),
5152            healthy=d.get('healthy'),
5153            hostname=d.get('hostname'),
5154            id=d.get('id'),
5155            name=d.get('name'),
5156            password=d.get('password'),
5157            port=d.get('port'),
5158            port_override=d.get('port_override'),
5159            secret_store_id=d.get('secret_store_id'),
5160            tags=d.get('tags'),
5161            tls_required=d.get('tls_required'),
5162            username=d.get('username'),
5163        )
ElasticacheRedis( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
5062    def __init__(
5063        self,
5064        bind_interface=None,
5065        egress_filter=None,
5066        healthy=None,
5067        hostname=None,
5068        id=None,
5069        name=None,
5070        password=None,
5071        port=None,
5072        port_override=None,
5073        secret_store_id=None,
5074        tags=None,
5075        tls_required=None,
5076        username=None,
5077    ):
5078        self.bind_interface = bind_interface if bind_interface is not None else ''
5079        '''
5080         Bind interface
5081        '''
5082        self.egress_filter = egress_filter if egress_filter is not None else ''
5083        '''
5084         A filter applied to the routing logic to pin datasource to nodes.
5085        '''
5086        self.healthy = healthy if healthy is not None else False
5087        '''
5088         True if the datasource is reachable and the credentials are valid.
5089        '''
5090        self.hostname = hostname if hostname is not None else ''
5091        self.id = id if id is not None else ''
5092        '''
5093         Unique identifier of the Resource.
5094        '''
5095        self.name = name if name is not None else ''
5096        '''
5097         Unique human-readable name of the Resource.
5098        '''
5099        self.password = password if password is not None else ''
5100        self.port = port if port is not None else 0
5101        self.port_override = port_override if port_override is not None else 0
5102        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5103        '''
5104         ID of the secret store containing credentials for this resource, if any.
5105        '''
5106        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5107        '''
5108         Tags is a map of key, value pairs.
5109        '''
5110        self.tls_required = tls_required if tls_required is not None else False
5111        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
5130    def to_dict(self):
5131        return {
5132            'bind_interface': self.bind_interface,
5133            'egress_filter': self.egress_filter,
5134            'healthy': self.healthy,
5135            'hostname': self.hostname,
5136            'id': self.id,
5137            'name': self.name,
5138            'password': self.password,
5139            'port': self.port,
5140            'port_override': self.port_override,
5141            'secret_store_id': self.secret_store_id,
5142            'tags': self.tags,
5143            'tls_required': self.tls_required,
5144            'username': self.username,
5145        }
@classmethod
def from_dict(cls, d)
5147    @classmethod
5148    def from_dict(cls, d):
5149        return cls(
5150            bind_interface=d.get('bind_interface'),
5151            egress_filter=d.get('egress_filter'),
5152            healthy=d.get('healthy'),
5153            hostname=d.get('hostname'),
5154            id=d.get('id'),
5155            name=d.get('name'),
5156            password=d.get('password'),
5157            port=d.get('port'),
5158            port_override=d.get('port_override'),
5159            secret_store_id=d.get('secret_store_id'),
5160            tags=d.get('tags'),
5161            tls_required=d.get('tls_required'),
5162            username=d.get('username'),
5163        )
class GCP:
5166class GCP:
5167    __slots__ = [
5168        'bind_interface',
5169        'egress_filter',
5170        'healthy',
5171        'id',
5172        'keyfile',
5173        'name',
5174        'scopes',
5175        'secret_store_id',
5176        'tags',
5177    ]
5178
5179    def __init__(
5180        self,
5181        bind_interface=None,
5182        egress_filter=None,
5183        healthy=None,
5184        id=None,
5185        keyfile=None,
5186        name=None,
5187        scopes=None,
5188        secret_store_id=None,
5189        tags=None,
5190    ):
5191        self.bind_interface = bind_interface if bind_interface is not None else ''
5192        '''
5193         Bind interface
5194        '''
5195        self.egress_filter = egress_filter if egress_filter is not None else ''
5196        '''
5197         A filter applied to the routing logic to pin datasource to nodes.
5198        '''
5199        self.healthy = healthy if healthy is not None else False
5200        '''
5201         True if the datasource is reachable and the credentials are valid.
5202        '''
5203        self.id = id if id is not None else ''
5204        '''
5205         Unique identifier of the Resource.
5206        '''
5207        self.keyfile = keyfile if keyfile is not None else ''
5208        self.name = name if name is not None else ''
5209        '''
5210         Unique human-readable name of the Resource.
5211        '''
5212        self.scopes = scopes if scopes is not None else ''
5213        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5214        '''
5215         ID of the secret store containing credentials for this resource, if any.
5216        '''
5217        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5218        '''
5219         Tags is a map of key, value pairs.
5220        '''
5221
5222    def __repr__(self):
5223        return '<sdm.GCP ' + \
5224            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5225            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5226            'healthy: ' + repr(self.healthy) + ' ' +\
5227            'id: ' + repr(self.id) + ' ' +\
5228            'keyfile: ' + repr(self.keyfile) + ' ' +\
5229            'name: ' + repr(self.name) + ' ' +\
5230            'scopes: ' + repr(self.scopes) + ' ' +\
5231            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5232            'tags: ' + repr(self.tags) + ' ' +\
5233            '>'
5234
5235    def to_dict(self):
5236        return {
5237            'bind_interface': self.bind_interface,
5238            'egress_filter': self.egress_filter,
5239            'healthy': self.healthy,
5240            'id': self.id,
5241            'keyfile': self.keyfile,
5242            'name': self.name,
5243            'scopes': self.scopes,
5244            'secret_store_id': self.secret_store_id,
5245            'tags': self.tags,
5246        }
5247
5248    @classmethod
5249    def from_dict(cls, d):
5250        return cls(
5251            bind_interface=d.get('bind_interface'),
5252            egress_filter=d.get('egress_filter'),
5253            healthy=d.get('healthy'),
5254            id=d.get('id'),
5255            keyfile=d.get('keyfile'),
5256            name=d.get('name'),
5257            scopes=d.get('scopes'),
5258            secret_store_id=d.get('secret_store_id'),
5259            tags=d.get('tags'),
5260        )
GCP( bind_interface=None, egress_filter=None, healthy=None, id=None, keyfile=None, name=None, scopes=None, secret_store_id=None, tags=None)
5179    def __init__(
5180        self,
5181        bind_interface=None,
5182        egress_filter=None,
5183        healthy=None,
5184        id=None,
5185        keyfile=None,
5186        name=None,
5187        scopes=None,
5188        secret_store_id=None,
5189        tags=None,
5190    ):
5191        self.bind_interface = bind_interface if bind_interface is not None else ''
5192        '''
5193         Bind interface
5194        '''
5195        self.egress_filter = egress_filter if egress_filter is not None else ''
5196        '''
5197         A filter applied to the routing logic to pin datasource to nodes.
5198        '''
5199        self.healthy = healthy if healthy is not None else False
5200        '''
5201         True if the datasource is reachable and the credentials are valid.
5202        '''
5203        self.id = id if id is not None else ''
5204        '''
5205         Unique identifier of the Resource.
5206        '''
5207        self.keyfile = keyfile if keyfile is not None else ''
5208        self.name = name if name is not None else ''
5209        '''
5210         Unique human-readable name of the Resource.
5211        '''
5212        self.scopes = scopes if scopes is not None else ''
5213        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5214        '''
5215         ID of the secret store containing credentials for this resource, if any.
5216        '''
5217        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5218        '''
5219         Tags is a map of key, value pairs.
5220        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

keyfile
name

Unique human-readable name of the Resource.

scopes
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
5235    def to_dict(self):
5236        return {
5237            'bind_interface': self.bind_interface,
5238            'egress_filter': self.egress_filter,
5239            'healthy': self.healthy,
5240            'id': self.id,
5241            'keyfile': self.keyfile,
5242            'name': self.name,
5243            'scopes': self.scopes,
5244            'secret_store_id': self.secret_store_id,
5245            'tags': self.tags,
5246        }
@classmethod
def from_dict(cls, d)
5248    @classmethod
5249    def from_dict(cls, d):
5250        return cls(
5251            bind_interface=d.get('bind_interface'),
5252            egress_filter=d.get('egress_filter'),
5253            healthy=d.get('healthy'),
5254            id=d.get('id'),
5255            keyfile=d.get('keyfile'),
5256            name=d.get('name'),
5257            scopes=d.get('scopes'),
5258            secret_store_id=d.get('secret_store_id'),
5259            tags=d.get('tags'),
5260        )
class GCPStore:
5263class GCPStore:
5264    __slots__ = [
5265        'id',
5266        'name',
5267        'projectid',
5268        'tags',
5269    ]
5270
5271    def __init__(
5272        self,
5273        id=None,
5274        name=None,
5275        projectid=None,
5276        tags=None,
5277    ):
5278        self.id = id if id is not None else ''
5279        '''
5280         Unique identifier of the SecretStore.
5281        '''
5282        self.name = name if name is not None else ''
5283        '''
5284         Unique human-readable name of the SecretStore.
5285        '''
5286        self.projectid = projectid if projectid is not None else ''
5287        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5288        '''
5289         Tags is a map of key, value pairs.
5290        '''
5291
5292    def __repr__(self):
5293        return '<sdm.GCPStore ' + \
5294            'id: ' + repr(self.id) + ' ' +\
5295            'name: ' + repr(self.name) + ' ' +\
5296            'projectid: ' + repr(self.projectid) + ' ' +\
5297            'tags: ' + repr(self.tags) + ' ' +\
5298            '>'
5299
5300    def to_dict(self):
5301        return {
5302            'id': self.id,
5303            'name': self.name,
5304            'projectid': self.projectid,
5305            'tags': self.tags,
5306        }
5307
5308    @classmethod
5309    def from_dict(cls, d):
5310        return cls(
5311            id=d.get('id'),
5312            name=d.get('name'),
5313            projectid=d.get('projectid'),
5314            tags=d.get('tags'),
5315        )
GCPStore(id=None, name=None, projectid=None, tags=None)
5271    def __init__(
5272        self,
5273        id=None,
5274        name=None,
5275        projectid=None,
5276        tags=None,
5277    ):
5278        self.id = id if id is not None else ''
5279        '''
5280         Unique identifier of the SecretStore.
5281        '''
5282        self.name = name if name is not None else ''
5283        '''
5284         Unique human-readable name of the SecretStore.
5285        '''
5286        self.projectid = projectid if projectid is not None else ''
5287        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5288        '''
5289         Tags is a map of key, value pairs.
5290        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

projectid
tags

Tags is a map of key, value pairs.

def to_dict(self)
5300    def to_dict(self):
5301        return {
5302            'id': self.id,
5303            'name': self.name,
5304            'projectid': self.projectid,
5305            'tags': self.tags,
5306        }
@classmethod
def from_dict(cls, d)
5308    @classmethod
5309    def from_dict(cls, d):
5310        return cls(
5311            id=d.get('id'),
5312            name=d.get('name'),
5313            projectid=d.get('projectid'),
5314            tags=d.get('tags'),
5315        )
class Gateway:
5318class Gateway:
5319    '''
5320         Gateway represents a StrongDM CLI installation running in gateway mode.
5321    '''
5322    __slots__ = [
5323        'bind_address',
5324        'device',
5325        'gateway_filter',
5326        'id',
5327        'listen_address',
5328        'location',
5329        'name',
5330        'state',
5331        'tags',
5332        'version',
5333    ]
5334
5335    def __init__(
5336        self,
5337        bind_address=None,
5338        device=None,
5339        gateway_filter=None,
5340        id=None,
5341        listen_address=None,
5342        location=None,
5343        name=None,
5344        state=None,
5345        tags=None,
5346        version=None,
5347    ):
5348        self.bind_address = bind_address if bind_address is not None else ''
5349        '''
5350         The hostname/port tuple which the gateway daemon will bind to.
5351         If not provided on create, set to "0.0.0.0:listen_address_port".
5352        '''
5353        self.device = device if device is not None else ''
5354        '''
5355         Device is a read only device name uploaded by the gateway process when 
5356         it comes online.
5357        '''
5358        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
5359        '''
5360         GatewayFilter can be used to restrict the peering between relays and
5361         gateways.
5362        '''
5363        self.id = id if id is not None else ''
5364        '''
5365         Unique identifier of the Gateway.
5366        '''
5367        self.listen_address = listen_address if listen_address is not None else ''
5368        '''
5369         The public hostname/port tuple at which the gateway will be accessible to clients.
5370        '''
5371        self.location = location if location is not None else ''
5372        '''
5373         Location is a read only network location uploaded by the gateway process
5374         when it comes online.
5375        '''
5376        self.name = name if name is not None else ''
5377        '''
5378         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
5379        '''
5380        self.state = state if state is not None else ''
5381        '''
5382         The current state of the gateway. One of: "new", "verifying_restart",
5383         "restarting", "started", "stopped", "dead", "unknown"
5384        '''
5385        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5386        '''
5387         Tags is a map of key, value pairs.
5388        '''
5389        self.version = version if version is not None else ''
5390        '''
5391         Version is a read only sdm binary version uploaded by the gateway process
5392         when it comes online.
5393        '''
5394
5395    def __repr__(self):
5396        return '<sdm.Gateway ' + \
5397            'bind_address: ' + repr(self.bind_address) + ' ' +\
5398            'device: ' + repr(self.device) + ' ' +\
5399            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
5400            'id: ' + repr(self.id) + ' ' +\
5401            'listen_address: ' + repr(self.listen_address) + ' ' +\
5402            'location: ' + repr(self.location) + ' ' +\
5403            'name: ' + repr(self.name) + ' ' +\
5404            'state: ' + repr(self.state) + ' ' +\
5405            'tags: ' + repr(self.tags) + ' ' +\
5406            'version: ' + repr(self.version) + ' ' +\
5407            '>'
5408
5409    def to_dict(self):
5410        return {
5411            'bind_address': self.bind_address,
5412            'device': self.device,
5413            'gateway_filter': self.gateway_filter,
5414            'id': self.id,
5415            'listen_address': self.listen_address,
5416            'location': self.location,
5417            'name': self.name,
5418            'state': self.state,
5419            'tags': self.tags,
5420            'version': self.version,
5421        }
5422
5423    @classmethod
5424    def from_dict(cls, d):
5425        return cls(
5426            bind_address=d.get('bind_address'),
5427            device=d.get('device'),
5428            gateway_filter=d.get('gateway_filter'),
5429            id=d.get('id'),
5430            listen_address=d.get('listen_address'),
5431            location=d.get('location'),
5432            name=d.get('name'),
5433            state=d.get('state'),
5434            tags=d.get('tags'),
5435            version=d.get('version'),
5436        )

Gateway represents a StrongDM CLI installation running in gateway mode.

Gateway( bind_address=None, device=None, gateway_filter=None, id=None, listen_address=None, location=None, name=None, state=None, tags=None, version=None)
5335    def __init__(
5336        self,
5337        bind_address=None,
5338        device=None,
5339        gateway_filter=None,
5340        id=None,
5341        listen_address=None,
5342        location=None,
5343        name=None,
5344        state=None,
5345        tags=None,
5346        version=None,
5347    ):
5348        self.bind_address = bind_address if bind_address is not None else ''
5349        '''
5350         The hostname/port tuple which the gateway daemon will bind to.
5351         If not provided on create, set to "0.0.0.0:listen_address_port".
5352        '''
5353        self.device = device if device is not None else ''
5354        '''
5355         Device is a read only device name uploaded by the gateway process when 
5356         it comes online.
5357        '''
5358        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
5359        '''
5360         GatewayFilter can be used to restrict the peering between relays and
5361         gateways.
5362        '''
5363        self.id = id if id is not None else ''
5364        '''
5365         Unique identifier of the Gateway.
5366        '''
5367        self.listen_address = listen_address if listen_address is not None else ''
5368        '''
5369         The public hostname/port tuple at which the gateway will be accessible to clients.
5370        '''
5371        self.location = location if location is not None else ''
5372        '''
5373         Location is a read only network location uploaded by the gateway process
5374         when it comes online.
5375        '''
5376        self.name = name if name is not None else ''
5377        '''
5378         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
5379        '''
5380        self.state = state if state is not None else ''
5381        '''
5382         The current state of the gateway. One of: "new", "verifying_restart",
5383         "restarting", "started", "stopped", "dead", "unknown"
5384        '''
5385        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5386        '''
5387         Tags is a map of key, value pairs.
5388        '''
5389        self.version = version if version is not None else ''
5390        '''
5391         Version is a read only sdm binary version uploaded by the gateway process
5392         when it comes online.
5393        '''
bind_address

The hostname/port tuple which the gateway daemon will bind to. If not provided on create, set to "0.0.0.0:listen_address_port".

device

Device is a read only device name uploaded by the gateway process when it comes online.

gateway_filter

GatewayFilter can be used to restrict the peering between relays and gateways.

id

Unique identifier of the Gateway.

listen_address

The public hostname/port tuple at which the gateway will be accessible to clients.

location

Location is a read only network location uploaded by the gateway process when it comes online.

name

Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.

state

The current state of the gateway. One of: "new", "verifying_restart", "restarting", "started", "stopped", "dead", "unknown"

tags

Tags is a map of key, value pairs.

version

Version is a read only sdm binary version uploaded by the gateway process when it comes online.

def to_dict(self)
5409    def to_dict(self):
5410        return {
5411            'bind_address': self.bind_address,
5412            'device': self.device,
5413            'gateway_filter': self.gateway_filter,
5414            'id': self.id,
5415            'listen_address': self.listen_address,
5416            'location': self.location,
5417            'name': self.name,
5418            'state': self.state,
5419            'tags': self.tags,
5420            'version': self.version,
5421        }
@classmethod
def from_dict(cls, d)
5423    @classmethod
5424    def from_dict(cls, d):
5425        return cls(
5426            bind_address=d.get('bind_address'),
5427            device=d.get('device'),
5428            gateway_filter=d.get('gateway_filter'),
5429            id=d.get('id'),
5430            listen_address=d.get('listen_address'),
5431            location=d.get('location'),
5432            name=d.get('name'),
5433            state=d.get('state'),
5434            tags=d.get('tags'),
5435            version=d.get('version'),
5436        )
class GetResponseMetadata:
5439class GetResponseMetadata:
5440    '''
5441         GetResponseMetadata is reserved for future use.
5442    '''
5443    __slots__ = []
5444
5445    def __init__(self, ):
5446        pass
5447
5448    def __repr__(self):
5449        return '<sdm.GetResponseMetadata ' + \
5450            '>'
5451
5452    def to_dict(self):
5453        return {}
5454
5455    @classmethod
5456    def from_dict(cls, d):
5457        return cls()

GetResponseMetadata is reserved for future use.

GetResponseMetadata()
5445    def __init__(self, ):
5446        pass
def to_dict(self)
5452    def to_dict(self):
5453        return {}
@classmethod
def from_dict(cls, d)
5455    @classmethod
5456    def from_dict(cls, d):
5457        return cls()
class GoogleGKE:
5460class GoogleGKE:
5461    __slots__ = [
5462        'bind_interface',
5463        'certificate_authority',
5464        'egress_filter',
5465        'endpoint',
5466        'healthcheck_namespace',
5467        'healthy',
5468        'id',
5469        'name',
5470        'remote_identity_group_id',
5471        'remote_identity_healthcheck_username',
5472        'secret_store_id',
5473        'service_account_key',
5474        'tags',
5475    ]
5476
5477    def __init__(
5478        self,
5479        bind_interface=None,
5480        certificate_authority=None,
5481        egress_filter=None,
5482        endpoint=None,
5483        healthcheck_namespace=None,
5484        healthy=None,
5485        id=None,
5486        name=None,
5487        remote_identity_group_id=None,
5488        remote_identity_healthcheck_username=None,
5489        secret_store_id=None,
5490        service_account_key=None,
5491        tags=None,
5492    ):
5493        self.bind_interface = bind_interface if bind_interface is not None else ''
5494        '''
5495         Bind interface
5496        '''
5497        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5498        self.egress_filter = egress_filter if egress_filter is not None else ''
5499        '''
5500         A filter applied to the routing logic to pin datasource to nodes.
5501        '''
5502        self.endpoint = endpoint if endpoint is not None else ''
5503        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5504        '''
5505         The path used to check the health of your connection.  Defaults to `default`.
5506        '''
5507        self.healthy = healthy if healthy is not None else False
5508        '''
5509         True if the datasource is reachable and the credentials are valid.
5510        '''
5511        self.id = id if id is not None else ''
5512        '''
5513         Unique identifier of the Resource.
5514        '''
5515        self.name = name if name is not None else ''
5516        '''
5517         Unique human-readable name of the Resource.
5518        '''
5519        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5520        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5521        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5522        '''
5523         ID of the secret store containing credentials for this resource, if any.
5524        '''
5525        self.service_account_key = service_account_key if service_account_key is not None else ''
5526        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5527        '''
5528         Tags is a map of key, value pairs.
5529        '''
5530
5531    def __repr__(self):
5532        return '<sdm.GoogleGKE ' + \
5533            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5534            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5535            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5536            'endpoint: ' + repr(self.endpoint) + ' ' +\
5537            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5538            'healthy: ' + repr(self.healthy) + ' ' +\
5539            'id: ' + repr(self.id) + ' ' +\
5540            'name: ' + repr(self.name) + ' ' +\
5541            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
5542            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
5543            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5544            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
5545            'tags: ' + repr(self.tags) + ' ' +\
5546            '>'
5547
5548    def to_dict(self):
5549        return {
5550            'bind_interface': self.bind_interface,
5551            'certificate_authority': self.certificate_authority,
5552            'egress_filter': self.egress_filter,
5553            'endpoint': self.endpoint,
5554            'healthcheck_namespace': self.healthcheck_namespace,
5555            'healthy': self.healthy,
5556            'id': self.id,
5557            'name': self.name,
5558            'remote_identity_group_id': self.remote_identity_group_id,
5559            'remote_identity_healthcheck_username':
5560            self.remote_identity_healthcheck_username,
5561            'secret_store_id': self.secret_store_id,
5562            'service_account_key': self.service_account_key,
5563            'tags': self.tags,
5564        }
5565
5566    @classmethod
5567    def from_dict(cls, d):
5568        return cls(
5569            bind_interface=d.get('bind_interface'),
5570            certificate_authority=d.get('certificate_authority'),
5571            egress_filter=d.get('egress_filter'),
5572            endpoint=d.get('endpoint'),
5573            healthcheck_namespace=d.get('healthcheck_namespace'),
5574            healthy=d.get('healthy'),
5575            id=d.get('id'),
5576            name=d.get('name'),
5577            remote_identity_group_id=d.get('remote_identity_group_id'),
5578            remote_identity_healthcheck_username=d.get(
5579                'remote_identity_healthcheck_username'),
5580            secret_store_id=d.get('secret_store_id'),
5581            service_account_key=d.get('service_account_key'),
5582            tags=d.get('tags'),
5583        )
GoogleGKE( bind_interface=None, certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, service_account_key=None, tags=None)
5477    def __init__(
5478        self,
5479        bind_interface=None,
5480        certificate_authority=None,
5481        egress_filter=None,
5482        endpoint=None,
5483        healthcheck_namespace=None,
5484        healthy=None,
5485        id=None,
5486        name=None,
5487        remote_identity_group_id=None,
5488        remote_identity_healthcheck_username=None,
5489        secret_store_id=None,
5490        service_account_key=None,
5491        tags=None,
5492    ):
5493        self.bind_interface = bind_interface if bind_interface is not None else ''
5494        '''
5495         Bind interface
5496        '''
5497        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5498        self.egress_filter = egress_filter if egress_filter is not None else ''
5499        '''
5500         A filter applied to the routing logic to pin datasource to nodes.
5501        '''
5502        self.endpoint = endpoint if endpoint is not None else ''
5503        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5504        '''
5505         The path used to check the health of your connection.  Defaults to `default`.
5506        '''
5507        self.healthy = healthy if healthy is not None else False
5508        '''
5509         True if the datasource is reachable and the credentials are valid.
5510        '''
5511        self.id = id if id is not None else ''
5512        '''
5513         Unique identifier of the Resource.
5514        '''
5515        self.name = name if name is not None else ''
5516        '''
5517         Unique human-readable name of the Resource.
5518        '''
5519        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5520        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5521        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5522        '''
5523         ID of the secret store containing credentials for this resource, if any.
5524        '''
5525        self.service_account_key = service_account_key if service_account_key is not None else ''
5526        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5527        '''
5528         Tags is a map of key, value pairs.
5529        '''
bind_interface

Bind interface

certificate_authority
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

service_account_key
tags

Tags is a map of key, value pairs.

def to_dict(self)
5548    def to_dict(self):
5549        return {
5550            'bind_interface': self.bind_interface,
5551            'certificate_authority': self.certificate_authority,
5552            'egress_filter': self.egress_filter,
5553            'endpoint': self.endpoint,
5554            'healthcheck_namespace': self.healthcheck_namespace,
5555            'healthy': self.healthy,
5556            'id': self.id,
5557            'name': self.name,
5558            'remote_identity_group_id': self.remote_identity_group_id,
5559            'remote_identity_healthcheck_username':
5560            self.remote_identity_healthcheck_username,
5561            'secret_store_id': self.secret_store_id,
5562            'service_account_key': self.service_account_key,
5563            'tags': self.tags,
5564        }
@classmethod
def from_dict(cls, d)
5566    @classmethod
5567    def from_dict(cls, d):
5568        return cls(
5569            bind_interface=d.get('bind_interface'),
5570            certificate_authority=d.get('certificate_authority'),
5571            egress_filter=d.get('egress_filter'),
5572            endpoint=d.get('endpoint'),
5573            healthcheck_namespace=d.get('healthcheck_namespace'),
5574            healthy=d.get('healthy'),
5575            id=d.get('id'),
5576            name=d.get('name'),
5577            remote_identity_group_id=d.get('remote_identity_group_id'),
5578            remote_identity_healthcheck_username=d.get(
5579                'remote_identity_healthcheck_username'),
5580            secret_store_id=d.get('secret_store_id'),
5581            service_account_key=d.get('service_account_key'),
5582            tags=d.get('tags'),
5583        )
class GoogleGKEUserImpersonation:
5586class GoogleGKEUserImpersonation:
5587    __slots__ = [
5588        'bind_interface',
5589        'certificate_authority',
5590        'egress_filter',
5591        'endpoint',
5592        'healthcheck_namespace',
5593        'healthy',
5594        'id',
5595        'name',
5596        'secret_store_id',
5597        'service_account_key',
5598        'tags',
5599    ]
5600
5601    def __init__(
5602        self,
5603        bind_interface=None,
5604        certificate_authority=None,
5605        egress_filter=None,
5606        endpoint=None,
5607        healthcheck_namespace=None,
5608        healthy=None,
5609        id=None,
5610        name=None,
5611        secret_store_id=None,
5612        service_account_key=None,
5613        tags=None,
5614    ):
5615        self.bind_interface = bind_interface if bind_interface is not None else ''
5616        '''
5617         Bind interface
5618        '''
5619        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5620        self.egress_filter = egress_filter if egress_filter is not None else ''
5621        '''
5622         A filter applied to the routing logic to pin datasource to nodes.
5623        '''
5624        self.endpoint = endpoint if endpoint is not None else ''
5625        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5626        '''
5627         The path used to check the health of your connection.  Defaults to `default`.
5628        '''
5629        self.healthy = healthy if healthy is not None else False
5630        '''
5631         True if the datasource is reachable and the credentials are valid.
5632        '''
5633        self.id = id if id is not None else ''
5634        '''
5635         Unique identifier of the Resource.
5636        '''
5637        self.name = name if name is not None else ''
5638        '''
5639         Unique human-readable name of the Resource.
5640        '''
5641        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5642        '''
5643         ID of the secret store containing credentials for this resource, if any.
5644        '''
5645        self.service_account_key = service_account_key if service_account_key is not None else ''
5646        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5647        '''
5648         Tags is a map of key, value pairs.
5649        '''
5650
5651    def __repr__(self):
5652        return '<sdm.GoogleGKEUserImpersonation ' + \
5653            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5654            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5655            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5656            'endpoint: ' + repr(self.endpoint) + ' ' +\
5657            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5658            'healthy: ' + repr(self.healthy) + ' ' +\
5659            'id: ' + repr(self.id) + ' ' +\
5660            'name: ' + repr(self.name) + ' ' +\
5661            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5662            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
5663            'tags: ' + repr(self.tags) + ' ' +\
5664            '>'
5665
5666    def to_dict(self):
5667        return {
5668            'bind_interface': self.bind_interface,
5669            'certificate_authority': self.certificate_authority,
5670            'egress_filter': self.egress_filter,
5671            'endpoint': self.endpoint,
5672            'healthcheck_namespace': self.healthcheck_namespace,
5673            'healthy': self.healthy,
5674            'id': self.id,
5675            'name': self.name,
5676            'secret_store_id': self.secret_store_id,
5677            'service_account_key': self.service_account_key,
5678            'tags': self.tags,
5679        }
5680
5681    @classmethod
5682    def from_dict(cls, d):
5683        return cls(
5684            bind_interface=d.get('bind_interface'),
5685            certificate_authority=d.get('certificate_authority'),
5686            egress_filter=d.get('egress_filter'),
5687            endpoint=d.get('endpoint'),
5688            healthcheck_namespace=d.get('healthcheck_namespace'),
5689            healthy=d.get('healthy'),
5690            id=d.get('id'),
5691            name=d.get('name'),
5692            secret_store_id=d.get('secret_store_id'),
5693            service_account_key=d.get('service_account_key'),
5694            tags=d.get('tags'),
5695        )
GoogleGKEUserImpersonation( bind_interface=None, certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, secret_store_id=None, service_account_key=None, tags=None)
5601    def __init__(
5602        self,
5603        bind_interface=None,
5604        certificate_authority=None,
5605        egress_filter=None,
5606        endpoint=None,
5607        healthcheck_namespace=None,
5608        healthy=None,
5609        id=None,
5610        name=None,
5611        secret_store_id=None,
5612        service_account_key=None,
5613        tags=None,
5614    ):
5615        self.bind_interface = bind_interface if bind_interface is not None else ''
5616        '''
5617         Bind interface
5618        '''
5619        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5620        self.egress_filter = egress_filter if egress_filter is not None else ''
5621        '''
5622         A filter applied to the routing logic to pin datasource to nodes.
5623        '''
5624        self.endpoint = endpoint if endpoint is not None else ''
5625        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5626        '''
5627         The path used to check the health of your connection.  Defaults to `default`.
5628        '''
5629        self.healthy = healthy if healthy is not None else False
5630        '''
5631         True if the datasource is reachable and the credentials are valid.
5632        '''
5633        self.id = id if id is not None else ''
5634        '''
5635         Unique identifier of the Resource.
5636        '''
5637        self.name = name if name is not None else ''
5638        '''
5639         Unique human-readable name of the Resource.
5640        '''
5641        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5642        '''
5643         ID of the secret store containing credentials for this resource, if any.
5644        '''
5645        self.service_account_key = service_account_key if service_account_key is not None else ''
5646        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5647        '''
5648         Tags is a map of key, value pairs.
5649        '''
bind_interface

Bind interface

certificate_authority
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

service_account_key
tags

Tags is a map of key, value pairs.

def to_dict(self)
5666    def to_dict(self):
5667        return {
5668            'bind_interface': self.bind_interface,
5669            'certificate_authority': self.certificate_authority,
5670            'egress_filter': self.egress_filter,
5671            'endpoint': self.endpoint,
5672            'healthcheck_namespace': self.healthcheck_namespace,
5673            'healthy': self.healthy,
5674            'id': self.id,
5675            'name': self.name,
5676            'secret_store_id': self.secret_store_id,
5677            'service_account_key': self.service_account_key,
5678            'tags': self.tags,
5679        }
@classmethod
def from_dict(cls, d)
5681    @classmethod
5682    def from_dict(cls, d):
5683        return cls(
5684            bind_interface=d.get('bind_interface'),
5685            certificate_authority=d.get('certificate_authority'),
5686            egress_filter=d.get('egress_filter'),
5687            endpoint=d.get('endpoint'),
5688            healthcheck_namespace=d.get('healthcheck_namespace'),
5689            healthy=d.get('healthy'),
5690            id=d.get('id'),
5691            name=d.get('name'),
5692            secret_store_id=d.get('secret_store_id'),
5693            service_account_key=d.get('service_account_key'),
5694            tags=d.get('tags'),
5695        )
class Greenplum:
5698class Greenplum:
5699    __slots__ = [
5700        'bind_interface',
5701        'database',
5702        'egress_filter',
5703        'healthy',
5704        'hostname',
5705        'id',
5706        'name',
5707        'override_database',
5708        'password',
5709        'port',
5710        'port_override',
5711        'secret_store_id',
5712        'tags',
5713        'username',
5714    ]
5715
5716    def __init__(
5717        self,
5718        bind_interface=None,
5719        database=None,
5720        egress_filter=None,
5721        healthy=None,
5722        hostname=None,
5723        id=None,
5724        name=None,
5725        override_database=None,
5726        password=None,
5727        port=None,
5728        port_override=None,
5729        secret_store_id=None,
5730        tags=None,
5731        username=None,
5732    ):
5733        self.bind_interface = bind_interface if bind_interface is not None else ''
5734        '''
5735         Bind interface
5736        '''
5737        self.database = database if database is not None else ''
5738        self.egress_filter = egress_filter if egress_filter is not None else ''
5739        '''
5740         A filter applied to the routing logic to pin datasource to nodes.
5741        '''
5742        self.healthy = healthy if healthy is not None else False
5743        '''
5744         True if the datasource is reachable and the credentials are valid.
5745        '''
5746        self.hostname = hostname if hostname is not None else ''
5747        self.id = id if id is not None else ''
5748        '''
5749         Unique identifier of the Resource.
5750        '''
5751        self.name = name if name is not None else ''
5752        '''
5753         Unique human-readable name of the Resource.
5754        '''
5755        self.override_database = override_database if override_database is not None else False
5756        self.password = password if password is not None else ''
5757        self.port = port if port is not None else 0
5758        self.port_override = port_override if port_override is not None else 0
5759        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5760        '''
5761         ID of the secret store containing credentials for this resource, if any.
5762        '''
5763        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5764        '''
5765         Tags is a map of key, value pairs.
5766        '''
5767        self.username = username if username is not None else ''
5768
5769    def __repr__(self):
5770        return '<sdm.Greenplum ' + \
5771            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5772            'database: ' + repr(self.database) + ' ' +\
5773            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5774            'healthy: ' + repr(self.healthy) + ' ' +\
5775            'hostname: ' + repr(self.hostname) + ' ' +\
5776            'id: ' + repr(self.id) + ' ' +\
5777            'name: ' + repr(self.name) + ' ' +\
5778            'override_database: ' + repr(self.override_database) + ' ' +\
5779            'password: ' + repr(self.password) + ' ' +\
5780            'port: ' + repr(self.port) + ' ' +\
5781            'port_override: ' + repr(self.port_override) + ' ' +\
5782            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5783            'tags: ' + repr(self.tags) + ' ' +\
5784            'username: ' + repr(self.username) + ' ' +\
5785            '>'
5786
5787    def to_dict(self):
5788        return {
5789            'bind_interface': self.bind_interface,
5790            'database': self.database,
5791            'egress_filter': self.egress_filter,
5792            'healthy': self.healthy,
5793            'hostname': self.hostname,
5794            'id': self.id,
5795            'name': self.name,
5796            'override_database': self.override_database,
5797            'password': self.password,
5798            'port': self.port,
5799            'port_override': self.port_override,
5800            'secret_store_id': self.secret_store_id,
5801            'tags': self.tags,
5802            'username': self.username,
5803        }
5804
5805    @classmethod
5806    def from_dict(cls, d):
5807        return cls(
5808            bind_interface=d.get('bind_interface'),
5809            database=d.get('database'),
5810            egress_filter=d.get('egress_filter'),
5811            healthy=d.get('healthy'),
5812            hostname=d.get('hostname'),
5813            id=d.get('id'),
5814            name=d.get('name'),
5815            override_database=d.get('override_database'),
5816            password=d.get('password'),
5817            port=d.get('port'),
5818            port_override=d.get('port_override'),
5819            secret_store_id=d.get('secret_store_id'),
5820            tags=d.get('tags'),
5821            username=d.get('username'),
5822        )
Greenplum( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
5716    def __init__(
5717        self,
5718        bind_interface=None,
5719        database=None,
5720        egress_filter=None,
5721        healthy=None,
5722        hostname=None,
5723        id=None,
5724        name=None,
5725        override_database=None,
5726        password=None,
5727        port=None,
5728        port_override=None,
5729        secret_store_id=None,
5730        tags=None,
5731        username=None,
5732    ):
5733        self.bind_interface = bind_interface if bind_interface is not None else ''
5734        '''
5735         Bind interface
5736        '''
5737        self.database = database if database is not None else ''
5738        self.egress_filter = egress_filter if egress_filter is not None else ''
5739        '''
5740         A filter applied to the routing logic to pin datasource to nodes.
5741        '''
5742        self.healthy = healthy if healthy is not None else False
5743        '''
5744         True if the datasource is reachable and the credentials are valid.
5745        '''
5746        self.hostname = hostname if hostname is not None else ''
5747        self.id = id if id is not None else ''
5748        '''
5749         Unique identifier of the Resource.
5750        '''
5751        self.name = name if name is not None else ''
5752        '''
5753         Unique human-readable name of the Resource.
5754        '''
5755        self.override_database = override_database if override_database is not None else False
5756        self.password = password if password is not None else ''
5757        self.port = port if port is not None else 0
5758        self.port_override = port_override if port_override is not None else 0
5759        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5760        '''
5761         ID of the secret store containing credentials for this resource, if any.
5762        '''
5763        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5764        '''
5765         Tags is a map of key, value pairs.
5766        '''
5767        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
5787    def to_dict(self):
5788        return {
5789            'bind_interface': self.bind_interface,
5790            'database': self.database,
5791            'egress_filter': self.egress_filter,
5792            'healthy': self.healthy,
5793            'hostname': self.hostname,
5794            'id': self.id,
5795            'name': self.name,
5796            'override_database': self.override_database,
5797            'password': self.password,
5798            'port': self.port,
5799            'port_override': self.port_override,
5800            'secret_store_id': self.secret_store_id,
5801            'tags': self.tags,
5802            'username': self.username,
5803        }
@classmethod
def from_dict(cls, d)
5805    @classmethod
5806    def from_dict(cls, d):
5807        return cls(
5808            bind_interface=d.get('bind_interface'),
5809            database=d.get('database'),
5810            egress_filter=d.get('egress_filter'),
5811            healthy=d.get('healthy'),
5812            hostname=d.get('hostname'),
5813            id=d.get('id'),
5814            name=d.get('name'),
5815            override_database=d.get('override_database'),
5816            password=d.get('password'),
5817            port=d.get('port'),
5818            port_override=d.get('port_override'),
5819            secret_store_id=d.get('secret_store_id'),
5820            tags=d.get('tags'),
5821            username=d.get('username'),
5822        )
class HTTPAuth:
5825class HTTPAuth:
5826    __slots__ = [
5827        'auth_header',
5828        'bind_interface',
5829        'default_path',
5830        'egress_filter',
5831        'headers_blacklist',
5832        'healthcheck_path',
5833        'healthy',
5834        'host_override',
5835        'id',
5836        'name',
5837        'secret_store_id',
5838        'subdomain',
5839        'tags',
5840        'url',
5841    ]
5842
5843    def __init__(
5844        self,
5845        auth_header=None,
5846        bind_interface=None,
5847        default_path=None,
5848        egress_filter=None,
5849        headers_blacklist=None,
5850        healthcheck_path=None,
5851        healthy=None,
5852        host_override=None,
5853        id=None,
5854        name=None,
5855        secret_store_id=None,
5856        subdomain=None,
5857        tags=None,
5858        url=None,
5859    ):
5860        self.auth_header = auth_header if auth_header is not None else ''
5861        self.bind_interface = bind_interface if bind_interface is not None else ''
5862        '''
5863         Bind interface
5864        '''
5865        self.default_path = default_path if default_path is not None else ''
5866        self.egress_filter = egress_filter if egress_filter is not None else ''
5867        '''
5868         A filter applied to the routing logic to pin datasource to nodes.
5869        '''
5870        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5871        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5872        self.healthy = healthy if healthy is not None else False
5873        '''
5874         True if the datasource is reachable and the credentials are valid.
5875        '''
5876        self.host_override = host_override if host_override is not None else ''
5877        self.id = id if id is not None else ''
5878        '''
5879         Unique identifier of the Resource.
5880        '''
5881        self.name = name if name is not None else ''
5882        '''
5883         Unique human-readable name of the Resource.
5884        '''
5885        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5886        '''
5887         ID of the secret store containing credentials for this resource, if any.
5888        '''
5889        self.subdomain = subdomain if subdomain is not None else ''
5890        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5891        '''
5892         Tags is a map of key, value pairs.
5893        '''
5894        self.url = url if url is not None else ''
5895
5896    def __repr__(self):
5897        return '<sdm.HTTPAuth ' + \
5898            'auth_header: ' + repr(self.auth_header) + ' ' +\
5899            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5900            'default_path: ' + repr(self.default_path) + ' ' +\
5901            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5902            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
5903            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
5904            'healthy: ' + repr(self.healthy) + ' ' +\
5905            'host_override: ' + repr(self.host_override) + ' ' +\
5906            'id: ' + repr(self.id) + ' ' +\
5907            'name: ' + repr(self.name) + ' ' +\
5908            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5909            'subdomain: ' + repr(self.subdomain) + ' ' +\
5910            'tags: ' + repr(self.tags) + ' ' +\
5911            'url: ' + repr(self.url) + ' ' +\
5912            '>'
5913
5914    def to_dict(self):
5915        return {
5916            'auth_header': self.auth_header,
5917            'bind_interface': self.bind_interface,
5918            'default_path': self.default_path,
5919            'egress_filter': self.egress_filter,
5920            'headers_blacklist': self.headers_blacklist,
5921            'healthcheck_path': self.healthcheck_path,
5922            'healthy': self.healthy,
5923            'host_override': self.host_override,
5924            'id': self.id,
5925            'name': self.name,
5926            'secret_store_id': self.secret_store_id,
5927            'subdomain': self.subdomain,
5928            'tags': self.tags,
5929            'url': self.url,
5930        }
5931
5932    @classmethod
5933    def from_dict(cls, d):
5934        return cls(
5935            auth_header=d.get('auth_header'),
5936            bind_interface=d.get('bind_interface'),
5937            default_path=d.get('default_path'),
5938            egress_filter=d.get('egress_filter'),
5939            headers_blacklist=d.get('headers_blacklist'),
5940            healthcheck_path=d.get('healthcheck_path'),
5941            healthy=d.get('healthy'),
5942            host_override=d.get('host_override'),
5943            id=d.get('id'),
5944            name=d.get('name'),
5945            secret_store_id=d.get('secret_store_id'),
5946            subdomain=d.get('subdomain'),
5947            tags=d.get('tags'),
5948            url=d.get('url'),
5949        )
HTTPAuth( auth_header=None, bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, host_override=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None)
5843    def __init__(
5844        self,
5845        auth_header=None,
5846        bind_interface=None,
5847        default_path=None,
5848        egress_filter=None,
5849        headers_blacklist=None,
5850        healthcheck_path=None,
5851        healthy=None,
5852        host_override=None,
5853        id=None,
5854        name=None,
5855        secret_store_id=None,
5856        subdomain=None,
5857        tags=None,
5858        url=None,
5859    ):
5860        self.auth_header = auth_header if auth_header is not None else ''
5861        self.bind_interface = bind_interface if bind_interface is not None else ''
5862        '''
5863         Bind interface
5864        '''
5865        self.default_path = default_path if default_path is not None else ''
5866        self.egress_filter = egress_filter if egress_filter is not None else ''
5867        '''
5868         A filter applied to the routing logic to pin datasource to nodes.
5869        '''
5870        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5871        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5872        self.healthy = healthy if healthy is not None else False
5873        '''
5874         True if the datasource is reachable and the credentials are valid.
5875        '''
5876        self.host_override = host_override if host_override is not None else ''
5877        self.id = id if id is not None else ''
5878        '''
5879         Unique identifier of the Resource.
5880        '''
5881        self.name = name if name is not None else ''
5882        '''
5883         Unique human-readable name of the Resource.
5884        '''
5885        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5886        '''
5887         ID of the secret store containing credentials for this resource, if any.
5888        '''
5889        self.subdomain = subdomain if subdomain is not None else ''
5890        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5891        '''
5892         Tags is a map of key, value pairs.
5893        '''
5894        self.url = url if url is not None else ''
auth_header
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

host_override
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
def to_dict(self)
5914    def to_dict(self):
5915        return {
5916            'auth_header': self.auth_header,
5917            'bind_interface': self.bind_interface,
5918            'default_path': self.default_path,
5919            'egress_filter': self.egress_filter,
5920            'headers_blacklist': self.headers_blacklist,
5921            'healthcheck_path': self.healthcheck_path,
5922            'healthy': self.healthy,
5923            'host_override': self.host_override,
5924            'id': self.id,
5925            'name': self.name,
5926            'secret_store_id': self.secret_store_id,
5927            'subdomain': self.subdomain,
5928            'tags': self.tags,
5929            'url': self.url,
5930        }
@classmethod
def from_dict(cls, d)
5932    @classmethod
5933    def from_dict(cls, d):
5934        return cls(
5935            auth_header=d.get('auth_header'),
5936            bind_interface=d.get('bind_interface'),
5937            default_path=d.get('default_path'),
5938            egress_filter=d.get('egress_filter'),
5939            headers_blacklist=d.get('headers_blacklist'),
5940            healthcheck_path=d.get('healthcheck_path'),
5941            healthy=d.get('healthy'),
5942            host_override=d.get('host_override'),
5943            id=d.get('id'),
5944            name=d.get('name'),
5945            secret_store_id=d.get('secret_store_id'),
5946            subdomain=d.get('subdomain'),
5947            tags=d.get('tags'),
5948            url=d.get('url'),
5949        )
class HTTPBasicAuth:
5952class HTTPBasicAuth:
5953    __slots__ = [
5954        'bind_interface',
5955        'default_path',
5956        'egress_filter',
5957        'headers_blacklist',
5958        'healthcheck_path',
5959        'healthy',
5960        'host_override',
5961        'id',
5962        'name',
5963        'password',
5964        'secret_store_id',
5965        'subdomain',
5966        'tags',
5967        'url',
5968        'username',
5969    ]
5970
5971    def __init__(
5972        self,
5973        bind_interface=None,
5974        default_path=None,
5975        egress_filter=None,
5976        headers_blacklist=None,
5977        healthcheck_path=None,
5978        healthy=None,
5979        host_override=None,
5980        id=None,
5981        name=None,
5982        password=None,
5983        secret_store_id=None,
5984        subdomain=None,
5985        tags=None,
5986        url=None,
5987        username=None,
5988    ):
5989        self.bind_interface = bind_interface if bind_interface is not None else ''
5990        '''
5991         Bind interface
5992        '''
5993        self.default_path = default_path if default_path is not None else ''
5994        self.egress_filter = egress_filter if egress_filter is not None else ''
5995        '''
5996         A filter applied to the routing logic to pin datasource to nodes.
5997        '''
5998        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5999        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6000        self.healthy = healthy if healthy is not None else False
6001        '''
6002         True if the datasource is reachable and the credentials are valid.
6003        '''
6004        self.host_override = host_override if host_override is not None else ''
6005        self.id = id if id is not None else ''
6006        '''
6007         Unique identifier of the Resource.
6008        '''
6009        self.name = name if name is not None else ''
6010        '''
6011         Unique human-readable name of the Resource.
6012        '''
6013        self.password = password if password is not None else ''
6014        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6015        '''
6016         ID of the secret store containing credentials for this resource, if any.
6017        '''
6018        self.subdomain = subdomain if subdomain is not None else ''
6019        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6020        '''
6021         Tags is a map of key, value pairs.
6022        '''
6023        self.url = url if url is not None else ''
6024        self.username = username if username is not None else ''
6025
6026    def __repr__(self):
6027        return '<sdm.HTTPBasicAuth ' + \
6028            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6029            'default_path: ' + repr(self.default_path) + ' ' +\
6030            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6031            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
6032            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
6033            'healthy: ' + repr(self.healthy) + ' ' +\
6034            'host_override: ' + repr(self.host_override) + ' ' +\
6035            'id: ' + repr(self.id) + ' ' +\
6036            'name: ' + repr(self.name) + ' ' +\
6037            'password: ' + repr(self.password) + ' ' +\
6038            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6039            'subdomain: ' + repr(self.subdomain) + ' ' +\
6040            'tags: ' + repr(self.tags) + ' ' +\
6041            'url: ' + repr(self.url) + ' ' +\
6042            'username: ' + repr(self.username) + ' ' +\
6043            '>'
6044
6045    def to_dict(self):
6046        return {
6047            'bind_interface': self.bind_interface,
6048            'default_path': self.default_path,
6049            'egress_filter': self.egress_filter,
6050            'headers_blacklist': self.headers_blacklist,
6051            'healthcheck_path': self.healthcheck_path,
6052            'healthy': self.healthy,
6053            'host_override': self.host_override,
6054            'id': self.id,
6055            'name': self.name,
6056            'password': self.password,
6057            'secret_store_id': self.secret_store_id,
6058            'subdomain': self.subdomain,
6059            'tags': self.tags,
6060            'url': self.url,
6061            'username': self.username,
6062        }
6063
6064    @classmethod
6065    def from_dict(cls, d):
6066        return cls(
6067            bind_interface=d.get('bind_interface'),
6068            default_path=d.get('default_path'),
6069            egress_filter=d.get('egress_filter'),
6070            headers_blacklist=d.get('headers_blacklist'),
6071            healthcheck_path=d.get('healthcheck_path'),
6072            healthy=d.get('healthy'),
6073            host_override=d.get('host_override'),
6074            id=d.get('id'),
6075            name=d.get('name'),
6076            password=d.get('password'),
6077            secret_store_id=d.get('secret_store_id'),
6078            subdomain=d.get('subdomain'),
6079            tags=d.get('tags'),
6080            url=d.get('url'),
6081            username=d.get('username'),
6082        )
HTTPBasicAuth( bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, host_override=None, id=None, name=None, password=None, secret_store_id=None, subdomain=None, tags=None, url=None, username=None)
5971    def __init__(
5972        self,
5973        bind_interface=None,
5974        default_path=None,
5975        egress_filter=None,
5976        headers_blacklist=None,
5977        healthcheck_path=None,
5978        healthy=None,
5979        host_override=None,
5980        id=None,
5981        name=None,
5982        password=None,
5983        secret_store_id=None,
5984        subdomain=None,
5985        tags=None,
5986        url=None,
5987        username=None,
5988    ):
5989        self.bind_interface = bind_interface if bind_interface is not None else ''
5990        '''
5991         Bind interface
5992        '''
5993        self.default_path = default_path if default_path is not None else ''
5994        self.egress_filter = egress_filter if egress_filter is not None else ''
5995        '''
5996         A filter applied to the routing logic to pin datasource to nodes.
5997        '''
5998        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5999        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6000        self.healthy = healthy if healthy is not None else False
6001        '''
6002         True if the datasource is reachable and the credentials are valid.
6003        '''
6004        self.host_override = host_override if host_override is not None else ''
6005        self.id = id if id is not None else ''
6006        '''
6007         Unique identifier of the Resource.
6008        '''
6009        self.name = name if name is not None else ''
6010        '''
6011         Unique human-readable name of the Resource.
6012        '''
6013        self.password = password if password is not None else ''
6014        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6015        '''
6016         ID of the secret store containing credentials for this resource, if any.
6017        '''
6018        self.subdomain = subdomain if subdomain is not None else ''
6019        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6020        '''
6021         Tags is a map of key, value pairs.
6022        '''
6023        self.url = url if url is not None else ''
6024        self.username = username if username is not None else ''
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

host_override
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
username
def to_dict(self)
6045    def to_dict(self):
6046        return {
6047            'bind_interface': self.bind_interface,
6048            'default_path': self.default_path,
6049            'egress_filter': self.egress_filter,
6050            'headers_blacklist': self.headers_blacklist,
6051            'healthcheck_path': self.healthcheck_path,
6052            'healthy': self.healthy,
6053            'host_override': self.host_override,
6054            'id': self.id,
6055            'name': self.name,
6056            'password': self.password,
6057            'secret_store_id': self.secret_store_id,
6058            'subdomain': self.subdomain,
6059            'tags': self.tags,
6060            'url': self.url,
6061            'username': self.username,
6062        }
@classmethod
def from_dict(cls, d)
6064    @classmethod
6065    def from_dict(cls, d):
6066        return cls(
6067            bind_interface=d.get('bind_interface'),
6068            default_path=d.get('default_path'),
6069            egress_filter=d.get('egress_filter'),
6070            headers_blacklist=d.get('headers_blacklist'),
6071            healthcheck_path=d.get('healthcheck_path'),
6072            healthy=d.get('healthy'),
6073            host_override=d.get('host_override'),
6074            id=d.get('id'),
6075            name=d.get('name'),
6076            password=d.get('password'),
6077            secret_store_id=d.get('secret_store_id'),
6078            subdomain=d.get('subdomain'),
6079            tags=d.get('tags'),
6080            url=d.get('url'),
6081            username=d.get('username'),
6082        )
class HTTPNoAuth:
6085class HTTPNoAuth:
6086    __slots__ = [
6087        'bind_interface',
6088        'default_path',
6089        'egress_filter',
6090        'headers_blacklist',
6091        'healthcheck_path',
6092        'healthy',
6093        'host_override',
6094        'id',
6095        'name',
6096        'secret_store_id',
6097        'subdomain',
6098        'tags',
6099        'url',
6100    ]
6101
6102    def __init__(
6103        self,
6104        bind_interface=None,
6105        default_path=None,
6106        egress_filter=None,
6107        headers_blacklist=None,
6108        healthcheck_path=None,
6109        healthy=None,
6110        host_override=None,
6111        id=None,
6112        name=None,
6113        secret_store_id=None,
6114        subdomain=None,
6115        tags=None,
6116        url=None,
6117    ):
6118        self.bind_interface = bind_interface if bind_interface is not None else ''
6119        '''
6120         Bind interface
6121        '''
6122        self.default_path = default_path if default_path is not None else ''
6123        self.egress_filter = egress_filter if egress_filter is not None else ''
6124        '''
6125         A filter applied to the routing logic to pin datasource to nodes.
6126        '''
6127        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
6128        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6129        self.healthy = healthy if healthy is not None else False
6130        '''
6131         True if the datasource is reachable and the credentials are valid.
6132        '''
6133        self.host_override = host_override if host_override is not None else ''
6134        self.id = id if id is not None else ''
6135        '''
6136         Unique identifier of the Resource.
6137        '''
6138        self.name = name if name is not None else ''
6139        '''
6140         Unique human-readable name of the Resource.
6141        '''
6142        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6143        '''
6144         ID of the secret store containing credentials for this resource, if any.
6145        '''
6146        self.subdomain = subdomain if subdomain is not None else ''
6147        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6148        '''
6149         Tags is a map of key, value pairs.
6150        '''
6151        self.url = url if url is not None else ''
6152
6153    def __repr__(self):
6154        return '<sdm.HTTPNoAuth ' + \
6155            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6156            'default_path: ' + repr(self.default_path) + ' ' +\
6157            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6158            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
6159            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
6160            'healthy: ' + repr(self.healthy) + ' ' +\
6161            'host_override: ' + repr(self.host_override) + ' ' +\
6162            'id: ' + repr(self.id) + ' ' +\
6163            'name: ' + repr(self.name) + ' ' +\
6164            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6165            'subdomain: ' + repr(self.subdomain) + ' ' +\
6166            'tags: ' + repr(self.tags) + ' ' +\
6167            'url: ' + repr(self.url) + ' ' +\
6168            '>'
6169
6170    def to_dict(self):
6171        return {
6172            'bind_interface': self.bind_interface,
6173            'default_path': self.default_path,
6174            'egress_filter': self.egress_filter,
6175            'headers_blacklist': self.headers_blacklist,
6176            'healthcheck_path': self.healthcheck_path,
6177            'healthy': self.healthy,
6178            'host_override': self.host_override,
6179            'id': self.id,
6180            'name': self.name,
6181            'secret_store_id': self.secret_store_id,
6182            'subdomain': self.subdomain,
6183            'tags': self.tags,
6184            'url': self.url,
6185        }
6186
6187    @classmethod
6188    def from_dict(cls, d):
6189        return cls(
6190            bind_interface=d.get('bind_interface'),
6191            default_path=d.get('default_path'),
6192            egress_filter=d.get('egress_filter'),
6193            headers_blacklist=d.get('headers_blacklist'),
6194            healthcheck_path=d.get('healthcheck_path'),
6195            healthy=d.get('healthy'),
6196            host_override=d.get('host_override'),
6197            id=d.get('id'),
6198            name=d.get('name'),
6199            secret_store_id=d.get('secret_store_id'),
6200            subdomain=d.get('subdomain'),
6201            tags=d.get('tags'),
6202            url=d.get('url'),
6203        )
HTTPNoAuth( bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, host_override=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None)
6102    def __init__(
6103        self,
6104        bind_interface=None,
6105        default_path=None,
6106        egress_filter=None,
6107        headers_blacklist=None,
6108        healthcheck_path=None,
6109        healthy=None,
6110        host_override=None,
6111        id=None,
6112        name=None,
6113        secret_store_id=None,
6114        subdomain=None,
6115        tags=None,
6116        url=None,
6117    ):
6118        self.bind_interface = bind_interface if bind_interface is not None else ''
6119        '''
6120         Bind interface
6121        '''
6122        self.default_path = default_path if default_path is not None else ''
6123        self.egress_filter = egress_filter if egress_filter is not None else ''
6124        '''
6125         A filter applied to the routing logic to pin datasource to nodes.
6126        '''
6127        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
6128        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6129        self.healthy = healthy if healthy is not None else False
6130        '''
6131         True if the datasource is reachable and the credentials are valid.
6132        '''
6133        self.host_override = host_override if host_override is not None else ''
6134        self.id = id if id is not None else ''
6135        '''
6136         Unique identifier of the Resource.
6137        '''
6138        self.name = name if name is not None else ''
6139        '''
6140         Unique human-readable name of the Resource.
6141        '''
6142        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6143        '''
6144         ID of the secret store containing credentials for this resource, if any.
6145        '''
6146        self.subdomain = subdomain if subdomain is not None else ''
6147        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6148        '''
6149         Tags is a map of key, value pairs.
6150        '''
6151        self.url = url if url is not None else ''
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

host_override
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
def to_dict(self)
6170    def to_dict(self):
6171        return {
6172            'bind_interface': self.bind_interface,
6173            'default_path': self.default_path,
6174            'egress_filter': self.egress_filter,
6175            'headers_blacklist': self.headers_blacklist,
6176            'healthcheck_path': self.healthcheck_path,
6177            'healthy': self.healthy,
6178            'host_override': self.host_override,
6179            'id': self.id,
6180            'name': self.name,
6181            'secret_store_id': self.secret_store_id,
6182            'subdomain': self.subdomain,
6183            'tags': self.tags,
6184            'url': self.url,
6185        }
@classmethod
def from_dict(cls, d)
6187    @classmethod
6188    def from_dict(cls, d):
6189        return cls(
6190            bind_interface=d.get('bind_interface'),
6191            default_path=d.get('default_path'),
6192            egress_filter=d.get('egress_filter'),
6193            headers_blacklist=d.get('headers_blacklist'),
6194            healthcheck_path=d.get('healthcheck_path'),
6195            healthy=d.get('healthy'),
6196            host_override=d.get('host_override'),
6197            id=d.get('id'),
6198            name=d.get('name'),
6199            secret_store_id=d.get('secret_store_id'),
6200            subdomain=d.get('subdomain'),
6201            tags=d.get('tags'),
6202            url=d.get('url'),
6203        )
class Kubernetes:
6206class Kubernetes:
6207    __slots__ = [
6208        'bind_interface',
6209        'certificate_authority',
6210        'client_certificate',
6211        'client_key',
6212        'egress_filter',
6213        'healthcheck_namespace',
6214        'healthy',
6215        'hostname',
6216        'id',
6217        'name',
6218        'port',
6219        'port_override',
6220        'remote_identity_group_id',
6221        'remote_identity_healthcheck_username',
6222        'secret_store_id',
6223        'tags',
6224    ]
6225
6226    def __init__(
6227        self,
6228        bind_interface=None,
6229        certificate_authority=None,
6230        client_certificate=None,
6231        client_key=None,
6232        egress_filter=None,
6233        healthcheck_namespace=None,
6234        healthy=None,
6235        hostname=None,
6236        id=None,
6237        name=None,
6238        port=None,
6239        port_override=None,
6240        remote_identity_group_id=None,
6241        remote_identity_healthcheck_username=None,
6242        secret_store_id=None,
6243        tags=None,
6244    ):
6245        self.bind_interface = bind_interface if bind_interface is not None else ''
6246        '''
6247         Bind interface
6248        '''
6249        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6250        self.client_certificate = client_certificate if client_certificate is not None else ''
6251        self.client_key = client_key if client_key is not None else ''
6252        self.egress_filter = egress_filter if egress_filter is not None else ''
6253        '''
6254         A filter applied to the routing logic to pin datasource to nodes.
6255        '''
6256        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6257        '''
6258         The path used to check the health of your connection.  Defaults to `default`.
6259        '''
6260        self.healthy = healthy if healthy is not None else False
6261        '''
6262         True if the datasource is reachable and the credentials are valid.
6263        '''
6264        self.hostname = hostname if hostname is not None else ''
6265        self.id = id if id is not None else ''
6266        '''
6267         Unique identifier of the Resource.
6268        '''
6269        self.name = name if name is not None else ''
6270        '''
6271         Unique human-readable name of the Resource.
6272        '''
6273        self.port = port if port is not None else 0
6274        self.port_override = port_override if port_override is not None else 0
6275        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6276        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6277        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6278        '''
6279         ID of the secret store containing credentials for this resource, if any.
6280        '''
6281        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6282        '''
6283         Tags is a map of key, value pairs.
6284        '''
6285
6286    def __repr__(self):
6287        return '<sdm.Kubernetes ' + \
6288            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6289            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6290            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6291            'client_key: ' + repr(self.client_key) + ' ' +\
6292            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6293            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6294            'healthy: ' + repr(self.healthy) + ' ' +\
6295            'hostname: ' + repr(self.hostname) + ' ' +\
6296            'id: ' + repr(self.id) + ' ' +\
6297            'name: ' + repr(self.name) + ' ' +\
6298            'port: ' + repr(self.port) + ' ' +\
6299            'port_override: ' + repr(self.port_override) + ' ' +\
6300            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
6301            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
6302            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6303            'tags: ' + repr(self.tags) + ' ' +\
6304            '>'
6305
6306    def to_dict(self):
6307        return {
6308            'bind_interface': self.bind_interface,
6309            'certificate_authority': self.certificate_authority,
6310            'client_certificate': self.client_certificate,
6311            'client_key': self.client_key,
6312            'egress_filter': self.egress_filter,
6313            'healthcheck_namespace': self.healthcheck_namespace,
6314            'healthy': self.healthy,
6315            'hostname': self.hostname,
6316            'id': self.id,
6317            'name': self.name,
6318            'port': self.port,
6319            'port_override': self.port_override,
6320            'remote_identity_group_id': self.remote_identity_group_id,
6321            'remote_identity_healthcheck_username':
6322            self.remote_identity_healthcheck_username,
6323            'secret_store_id': self.secret_store_id,
6324            'tags': self.tags,
6325        }
6326
6327    @classmethod
6328    def from_dict(cls, d):
6329        return cls(
6330            bind_interface=d.get('bind_interface'),
6331            certificate_authority=d.get('certificate_authority'),
6332            client_certificate=d.get('client_certificate'),
6333            client_key=d.get('client_key'),
6334            egress_filter=d.get('egress_filter'),
6335            healthcheck_namespace=d.get('healthcheck_namespace'),
6336            healthy=d.get('healthy'),
6337            hostname=d.get('hostname'),
6338            id=d.get('id'),
6339            name=d.get('name'),
6340            port=d.get('port'),
6341            port_override=d.get('port_override'),
6342            remote_identity_group_id=d.get('remote_identity_group_id'),
6343            remote_identity_healthcheck_username=d.get(
6344                'remote_identity_healthcheck_username'),
6345            secret_store_id=d.get('secret_store_id'),
6346            tags=d.get('tags'),
6347        )
Kubernetes( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None)
6226    def __init__(
6227        self,
6228        bind_interface=None,
6229        certificate_authority=None,
6230        client_certificate=None,
6231        client_key=None,
6232        egress_filter=None,
6233        healthcheck_namespace=None,
6234        healthy=None,
6235        hostname=None,
6236        id=None,
6237        name=None,
6238        port=None,
6239        port_override=None,
6240        remote_identity_group_id=None,
6241        remote_identity_healthcheck_username=None,
6242        secret_store_id=None,
6243        tags=None,
6244    ):
6245        self.bind_interface = bind_interface if bind_interface is not None else ''
6246        '''
6247         Bind interface
6248        '''
6249        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6250        self.client_certificate = client_certificate if client_certificate is not None else ''
6251        self.client_key = client_key if client_key is not None else ''
6252        self.egress_filter = egress_filter if egress_filter is not None else ''
6253        '''
6254         A filter applied to the routing logic to pin datasource to nodes.
6255        '''
6256        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6257        '''
6258         The path used to check the health of your connection.  Defaults to `default`.
6259        '''
6260        self.healthy = healthy if healthy is not None else False
6261        '''
6262         True if the datasource is reachable and the credentials are valid.
6263        '''
6264        self.hostname = hostname if hostname is not None else ''
6265        self.id = id if id is not None else ''
6266        '''
6267         Unique identifier of the Resource.
6268        '''
6269        self.name = name if name is not None else ''
6270        '''
6271         Unique human-readable name of the Resource.
6272        '''
6273        self.port = port if port is not None else 0
6274        self.port_override = port_override if port_override is not None else 0
6275        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6276        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6277        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6278        '''
6279         ID of the secret store containing credentials for this resource, if any.
6280        '''
6281        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6282        '''
6283         Tags is a map of key, value pairs.
6284        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
6306    def to_dict(self):
6307        return {
6308            'bind_interface': self.bind_interface,
6309            'certificate_authority': self.certificate_authority,
6310            'client_certificate': self.client_certificate,
6311            'client_key': self.client_key,
6312            'egress_filter': self.egress_filter,
6313            'healthcheck_namespace': self.healthcheck_namespace,
6314            'healthy': self.healthy,
6315            'hostname': self.hostname,
6316            'id': self.id,
6317            'name': self.name,
6318            'port': self.port,
6319            'port_override': self.port_override,
6320            'remote_identity_group_id': self.remote_identity_group_id,
6321            'remote_identity_healthcheck_username':
6322            self.remote_identity_healthcheck_username,
6323            'secret_store_id': self.secret_store_id,
6324            'tags': self.tags,
6325        }
@classmethod
def from_dict(cls, d)
6327    @classmethod
6328    def from_dict(cls, d):
6329        return cls(
6330            bind_interface=d.get('bind_interface'),
6331            certificate_authority=d.get('certificate_authority'),
6332            client_certificate=d.get('client_certificate'),
6333            client_key=d.get('client_key'),
6334            egress_filter=d.get('egress_filter'),
6335            healthcheck_namespace=d.get('healthcheck_namespace'),
6336            healthy=d.get('healthy'),
6337            hostname=d.get('hostname'),
6338            id=d.get('id'),
6339            name=d.get('name'),
6340            port=d.get('port'),
6341            port_override=d.get('port_override'),
6342            remote_identity_group_id=d.get('remote_identity_group_id'),
6343            remote_identity_healthcheck_username=d.get(
6344                'remote_identity_healthcheck_username'),
6345            secret_store_id=d.get('secret_store_id'),
6346            tags=d.get('tags'),
6347        )
class KubernetesBasicAuth:
6350class KubernetesBasicAuth:
6351    __slots__ = [
6352        'bind_interface',
6353        'egress_filter',
6354        'healthcheck_namespace',
6355        'healthy',
6356        'hostname',
6357        'id',
6358        'name',
6359        'password',
6360        'port',
6361        'port_override',
6362        'secret_store_id',
6363        'tags',
6364        'username',
6365    ]
6366
6367    def __init__(
6368        self,
6369        bind_interface=None,
6370        egress_filter=None,
6371        healthcheck_namespace=None,
6372        healthy=None,
6373        hostname=None,
6374        id=None,
6375        name=None,
6376        password=None,
6377        port=None,
6378        port_override=None,
6379        secret_store_id=None,
6380        tags=None,
6381        username=None,
6382    ):
6383        self.bind_interface = bind_interface if bind_interface is not None else ''
6384        '''
6385         Bind interface
6386        '''
6387        self.egress_filter = egress_filter if egress_filter is not None else ''
6388        '''
6389         A filter applied to the routing logic to pin datasource to nodes.
6390        '''
6391        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6392        '''
6393         The path used to check the health of your connection.  Defaults to `default`.
6394        '''
6395        self.healthy = healthy if healthy is not None else False
6396        '''
6397         True if the datasource is reachable and the credentials are valid.
6398        '''
6399        self.hostname = hostname if hostname is not None else ''
6400        self.id = id if id is not None else ''
6401        '''
6402         Unique identifier of the Resource.
6403        '''
6404        self.name = name if name is not None else ''
6405        '''
6406         Unique human-readable name of the Resource.
6407        '''
6408        self.password = password if password is not None else ''
6409        self.port = port if port is not None else 0
6410        self.port_override = port_override if port_override is not None else 0
6411        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6412        '''
6413         ID of the secret store containing credentials for this resource, if any.
6414        '''
6415        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6416        '''
6417         Tags is a map of key, value pairs.
6418        '''
6419        self.username = username if username is not None else ''
6420
6421    def __repr__(self):
6422        return '<sdm.KubernetesBasicAuth ' + \
6423            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6424            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6425            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6426            'healthy: ' + repr(self.healthy) + ' ' +\
6427            'hostname: ' + repr(self.hostname) + ' ' +\
6428            'id: ' + repr(self.id) + ' ' +\
6429            'name: ' + repr(self.name) + ' ' +\
6430            'password: ' + repr(self.password) + ' ' +\
6431            'port: ' + repr(self.port) + ' ' +\
6432            'port_override: ' + repr(self.port_override) + ' ' +\
6433            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6434            'tags: ' + repr(self.tags) + ' ' +\
6435            'username: ' + repr(self.username) + ' ' +\
6436            '>'
6437
6438    def to_dict(self):
6439        return {
6440            'bind_interface': self.bind_interface,
6441            'egress_filter': self.egress_filter,
6442            'healthcheck_namespace': self.healthcheck_namespace,
6443            'healthy': self.healthy,
6444            'hostname': self.hostname,
6445            'id': self.id,
6446            'name': self.name,
6447            'password': self.password,
6448            'port': self.port,
6449            'port_override': self.port_override,
6450            'secret_store_id': self.secret_store_id,
6451            'tags': self.tags,
6452            'username': self.username,
6453        }
6454
6455    @classmethod
6456    def from_dict(cls, d):
6457        return cls(
6458            bind_interface=d.get('bind_interface'),
6459            egress_filter=d.get('egress_filter'),
6460            healthcheck_namespace=d.get('healthcheck_namespace'),
6461            healthy=d.get('healthy'),
6462            hostname=d.get('hostname'),
6463            id=d.get('id'),
6464            name=d.get('name'),
6465            password=d.get('password'),
6466            port=d.get('port'),
6467            port_override=d.get('port_override'),
6468            secret_store_id=d.get('secret_store_id'),
6469            tags=d.get('tags'),
6470            username=d.get('username'),
6471        )
KubernetesBasicAuth( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
6367    def __init__(
6368        self,
6369        bind_interface=None,
6370        egress_filter=None,
6371        healthcheck_namespace=None,
6372        healthy=None,
6373        hostname=None,
6374        id=None,
6375        name=None,
6376        password=None,
6377        port=None,
6378        port_override=None,
6379        secret_store_id=None,
6380        tags=None,
6381        username=None,
6382    ):
6383        self.bind_interface = bind_interface if bind_interface is not None else ''
6384        '''
6385         Bind interface
6386        '''
6387        self.egress_filter = egress_filter if egress_filter is not None else ''
6388        '''
6389         A filter applied to the routing logic to pin datasource to nodes.
6390        '''
6391        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6392        '''
6393         The path used to check the health of your connection.  Defaults to `default`.
6394        '''
6395        self.healthy = healthy if healthy is not None else False
6396        '''
6397         True if the datasource is reachable and the credentials are valid.
6398        '''
6399        self.hostname = hostname if hostname is not None else ''
6400        self.id = id if id is not None else ''
6401        '''
6402         Unique identifier of the Resource.
6403        '''
6404        self.name = name if name is not None else ''
6405        '''
6406         Unique human-readable name of the Resource.
6407        '''
6408        self.password = password if password is not None else ''
6409        self.port = port if port is not None else 0
6410        self.port_override = port_override if port_override is not None else 0
6411        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6412        '''
6413         ID of the secret store containing credentials for this resource, if any.
6414        '''
6415        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6416        '''
6417         Tags is a map of key, value pairs.
6418        '''
6419        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
6438    def to_dict(self):
6439        return {
6440            'bind_interface': self.bind_interface,
6441            'egress_filter': self.egress_filter,
6442            'healthcheck_namespace': self.healthcheck_namespace,
6443            'healthy': self.healthy,
6444            'hostname': self.hostname,
6445            'id': self.id,
6446            'name': self.name,
6447            'password': self.password,
6448            'port': self.port,
6449            'port_override': self.port_override,
6450            'secret_store_id': self.secret_store_id,
6451            'tags': self.tags,
6452            'username': self.username,
6453        }
@classmethod
def from_dict(cls, d)
6455    @classmethod
6456    def from_dict(cls, d):
6457        return cls(
6458            bind_interface=d.get('bind_interface'),
6459            egress_filter=d.get('egress_filter'),
6460            healthcheck_namespace=d.get('healthcheck_namespace'),
6461            healthy=d.get('healthy'),
6462            hostname=d.get('hostname'),
6463            id=d.get('id'),
6464            name=d.get('name'),
6465            password=d.get('password'),
6466            port=d.get('port'),
6467            port_override=d.get('port_override'),
6468            secret_store_id=d.get('secret_store_id'),
6469            tags=d.get('tags'),
6470            username=d.get('username'),
6471        )
class KubernetesServiceAccount:
6474class KubernetesServiceAccount:
6475    __slots__ = [
6476        'bind_interface',
6477        'egress_filter',
6478        'healthcheck_namespace',
6479        'healthy',
6480        'hostname',
6481        'id',
6482        'name',
6483        'port',
6484        'port_override',
6485        'remote_identity_group_id',
6486        'remote_identity_healthcheck_username',
6487        'secret_store_id',
6488        'tags',
6489        'token',
6490    ]
6491
6492    def __init__(
6493        self,
6494        bind_interface=None,
6495        egress_filter=None,
6496        healthcheck_namespace=None,
6497        healthy=None,
6498        hostname=None,
6499        id=None,
6500        name=None,
6501        port=None,
6502        port_override=None,
6503        remote_identity_group_id=None,
6504        remote_identity_healthcheck_username=None,
6505        secret_store_id=None,
6506        tags=None,
6507        token=None,
6508    ):
6509        self.bind_interface = bind_interface if bind_interface is not None else ''
6510        '''
6511         Bind interface
6512        '''
6513        self.egress_filter = egress_filter if egress_filter is not None else ''
6514        '''
6515         A filter applied to the routing logic to pin datasource to nodes.
6516        '''
6517        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6518        '''
6519         The path used to check the health of your connection.  Defaults to `default`.
6520        '''
6521        self.healthy = healthy if healthy is not None else False
6522        '''
6523         True if the datasource is reachable and the credentials are valid.
6524        '''
6525        self.hostname = hostname if hostname is not None else ''
6526        self.id = id if id is not None else ''
6527        '''
6528         Unique identifier of the Resource.
6529        '''
6530        self.name = name if name is not None else ''
6531        '''
6532         Unique human-readable name of the Resource.
6533        '''
6534        self.port = port if port is not None else 0
6535        self.port_override = port_override if port_override is not None else 0
6536        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6537        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6538        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6539        '''
6540         ID of the secret store containing credentials for this resource, if any.
6541        '''
6542        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6543        '''
6544         Tags is a map of key, value pairs.
6545        '''
6546        self.token = token if token is not None else ''
6547
6548    def __repr__(self):
6549        return '<sdm.KubernetesServiceAccount ' + \
6550            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6551            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6552            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6553            'healthy: ' + repr(self.healthy) + ' ' +\
6554            'hostname: ' + repr(self.hostname) + ' ' +\
6555            'id: ' + repr(self.id) + ' ' +\
6556            'name: ' + repr(self.name) + ' ' +\
6557            'port: ' + repr(self.port) + ' ' +\
6558            'port_override: ' + repr(self.port_override) + ' ' +\
6559            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
6560            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
6561            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6562            'tags: ' + repr(self.tags) + ' ' +\
6563            'token: ' + repr(self.token) + ' ' +\
6564            '>'
6565
6566    def to_dict(self):
6567        return {
6568            'bind_interface': self.bind_interface,
6569            'egress_filter': self.egress_filter,
6570            'healthcheck_namespace': self.healthcheck_namespace,
6571            'healthy': self.healthy,
6572            'hostname': self.hostname,
6573            'id': self.id,
6574            'name': self.name,
6575            'port': self.port,
6576            'port_override': self.port_override,
6577            'remote_identity_group_id': self.remote_identity_group_id,
6578            'remote_identity_healthcheck_username':
6579            self.remote_identity_healthcheck_username,
6580            'secret_store_id': self.secret_store_id,
6581            'tags': self.tags,
6582            'token': self.token,
6583        }
6584
6585    @classmethod
6586    def from_dict(cls, d):
6587        return cls(
6588            bind_interface=d.get('bind_interface'),
6589            egress_filter=d.get('egress_filter'),
6590            healthcheck_namespace=d.get('healthcheck_namespace'),
6591            healthy=d.get('healthy'),
6592            hostname=d.get('hostname'),
6593            id=d.get('id'),
6594            name=d.get('name'),
6595            port=d.get('port'),
6596            port_override=d.get('port_override'),
6597            remote_identity_group_id=d.get('remote_identity_group_id'),
6598            remote_identity_healthcheck_username=d.get(
6599                'remote_identity_healthcheck_username'),
6600            secret_store_id=d.get('secret_store_id'),
6601            tags=d.get('tags'),
6602            token=d.get('token'),
6603        )
KubernetesServiceAccount( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, token=None)
6492    def __init__(
6493        self,
6494        bind_interface=None,
6495        egress_filter=None,
6496        healthcheck_namespace=None,
6497        healthy=None,
6498        hostname=None,
6499        id=None,
6500        name=None,
6501        port=None,
6502        port_override=None,
6503        remote_identity_group_id=None,
6504        remote_identity_healthcheck_username=None,
6505        secret_store_id=None,
6506        tags=None,
6507        token=None,
6508    ):
6509        self.bind_interface = bind_interface if bind_interface is not None else ''
6510        '''
6511         Bind interface
6512        '''
6513        self.egress_filter = egress_filter if egress_filter is not None else ''
6514        '''
6515         A filter applied to the routing logic to pin datasource to nodes.
6516        '''
6517        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6518        '''
6519         The path used to check the health of your connection.  Defaults to `default`.
6520        '''
6521        self.healthy = healthy if healthy is not None else False
6522        '''
6523         True if the datasource is reachable and the credentials are valid.
6524        '''
6525        self.hostname = hostname if hostname is not None else ''
6526        self.id = id if id is not None else ''
6527        '''
6528         Unique identifier of the Resource.
6529        '''
6530        self.name = name if name is not None else ''
6531        '''
6532         Unique human-readable name of the Resource.
6533        '''
6534        self.port = port if port is not None else 0
6535        self.port_override = port_override if port_override is not None else 0
6536        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6537        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6538        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6539        '''
6540         ID of the secret store containing credentials for this resource, if any.
6541        '''
6542        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6543        '''
6544         Tags is a map of key, value pairs.
6545        '''
6546        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
6566    def to_dict(self):
6567        return {
6568            'bind_interface': self.bind_interface,
6569            'egress_filter': self.egress_filter,
6570            'healthcheck_namespace': self.healthcheck_namespace,
6571            'healthy': self.healthy,
6572            'hostname': self.hostname,
6573            'id': self.id,
6574            'name': self.name,
6575            'port': self.port,
6576            'port_override': self.port_override,
6577            'remote_identity_group_id': self.remote_identity_group_id,
6578            'remote_identity_healthcheck_username':
6579            self.remote_identity_healthcheck_username,
6580            'secret_store_id': self.secret_store_id,
6581            'tags': self.tags,
6582            'token': self.token,
6583        }
@classmethod
def from_dict(cls, d)
6585    @classmethod
6586    def from_dict(cls, d):
6587        return cls(
6588            bind_interface=d.get('bind_interface'),
6589            egress_filter=d.get('egress_filter'),
6590            healthcheck_namespace=d.get('healthcheck_namespace'),
6591            healthy=d.get('healthy'),
6592            hostname=d.get('hostname'),
6593            id=d.get('id'),
6594            name=d.get('name'),
6595            port=d.get('port'),
6596            port_override=d.get('port_override'),
6597            remote_identity_group_id=d.get('remote_identity_group_id'),
6598            remote_identity_healthcheck_username=d.get(
6599                'remote_identity_healthcheck_username'),
6600            secret_store_id=d.get('secret_store_id'),
6601            tags=d.get('tags'),
6602            token=d.get('token'),
6603        )
class KubernetesServiceAccountUserImpersonation:
6606class KubernetesServiceAccountUserImpersonation:
6607    __slots__ = [
6608        'bind_interface',
6609        'egress_filter',
6610        'healthcheck_namespace',
6611        'healthy',
6612        'hostname',
6613        'id',
6614        'name',
6615        'port',
6616        'port_override',
6617        'secret_store_id',
6618        'tags',
6619        'token',
6620    ]
6621
6622    def __init__(
6623        self,
6624        bind_interface=None,
6625        egress_filter=None,
6626        healthcheck_namespace=None,
6627        healthy=None,
6628        hostname=None,
6629        id=None,
6630        name=None,
6631        port=None,
6632        port_override=None,
6633        secret_store_id=None,
6634        tags=None,
6635        token=None,
6636    ):
6637        self.bind_interface = bind_interface if bind_interface is not None else ''
6638        '''
6639         Bind interface
6640        '''
6641        self.egress_filter = egress_filter if egress_filter is not None else ''
6642        '''
6643         A filter applied to the routing logic to pin datasource to nodes.
6644        '''
6645        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6646        '''
6647         The path used to check the health of your connection.  Defaults to `default`.
6648        '''
6649        self.healthy = healthy if healthy is not None else False
6650        '''
6651         True if the datasource is reachable and the credentials are valid.
6652        '''
6653        self.hostname = hostname if hostname is not None else ''
6654        self.id = id if id is not None else ''
6655        '''
6656         Unique identifier of the Resource.
6657        '''
6658        self.name = name if name is not None else ''
6659        '''
6660         Unique human-readable name of the Resource.
6661        '''
6662        self.port = port if port is not None else 0
6663        self.port_override = port_override if port_override is not None else 0
6664        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6665        '''
6666         ID of the secret store containing credentials for this resource, if any.
6667        '''
6668        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6669        '''
6670         Tags is a map of key, value pairs.
6671        '''
6672        self.token = token if token is not None else ''
6673
6674    def __repr__(self):
6675        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
6676            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6677            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6678            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6679            'healthy: ' + repr(self.healthy) + ' ' +\
6680            'hostname: ' + repr(self.hostname) + ' ' +\
6681            'id: ' + repr(self.id) + ' ' +\
6682            'name: ' + repr(self.name) + ' ' +\
6683            'port: ' + repr(self.port) + ' ' +\
6684            'port_override: ' + repr(self.port_override) + ' ' +\
6685            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6686            'tags: ' + repr(self.tags) + ' ' +\
6687            'token: ' + repr(self.token) + ' ' +\
6688            '>'
6689
6690    def to_dict(self):
6691        return {
6692            'bind_interface': self.bind_interface,
6693            'egress_filter': self.egress_filter,
6694            'healthcheck_namespace': self.healthcheck_namespace,
6695            'healthy': self.healthy,
6696            'hostname': self.hostname,
6697            'id': self.id,
6698            'name': self.name,
6699            'port': self.port,
6700            'port_override': self.port_override,
6701            'secret_store_id': self.secret_store_id,
6702            'tags': self.tags,
6703            'token': self.token,
6704        }
6705
6706    @classmethod
6707    def from_dict(cls, d):
6708        return cls(
6709            bind_interface=d.get('bind_interface'),
6710            egress_filter=d.get('egress_filter'),
6711            healthcheck_namespace=d.get('healthcheck_namespace'),
6712            healthy=d.get('healthy'),
6713            hostname=d.get('hostname'),
6714            id=d.get('id'),
6715            name=d.get('name'),
6716            port=d.get('port'),
6717            port_override=d.get('port_override'),
6718            secret_store_id=d.get('secret_store_id'),
6719            tags=d.get('tags'),
6720            token=d.get('token'),
6721        )
KubernetesServiceAccountUserImpersonation( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None, token=None)
6622    def __init__(
6623        self,
6624        bind_interface=None,
6625        egress_filter=None,
6626        healthcheck_namespace=None,
6627        healthy=None,
6628        hostname=None,
6629        id=None,
6630        name=None,
6631        port=None,
6632        port_override=None,
6633        secret_store_id=None,
6634        tags=None,
6635        token=None,
6636    ):
6637        self.bind_interface = bind_interface if bind_interface is not None else ''
6638        '''
6639         Bind interface
6640        '''
6641        self.egress_filter = egress_filter if egress_filter is not None else ''
6642        '''
6643         A filter applied to the routing logic to pin datasource to nodes.
6644        '''
6645        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6646        '''
6647         The path used to check the health of your connection.  Defaults to `default`.
6648        '''
6649        self.healthy = healthy if healthy is not None else False
6650        '''
6651         True if the datasource is reachable and the credentials are valid.
6652        '''
6653        self.hostname = hostname if hostname is not None else ''
6654        self.id = id if id is not None else ''
6655        '''
6656         Unique identifier of the Resource.
6657        '''
6658        self.name = name if name is not None else ''
6659        '''
6660         Unique human-readable name of the Resource.
6661        '''
6662        self.port = port if port is not None else 0
6663        self.port_override = port_override if port_override is not None else 0
6664        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6665        '''
6666         ID of the secret store containing credentials for this resource, if any.
6667        '''
6668        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6669        '''
6670         Tags is a map of key, value pairs.
6671        '''
6672        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
6690    def to_dict(self):
6691        return {
6692            'bind_interface': self.bind_interface,
6693            'egress_filter': self.egress_filter,
6694            'healthcheck_namespace': self.healthcheck_namespace,
6695            'healthy': self.healthy,
6696            'hostname': self.hostname,
6697            'id': self.id,
6698            'name': self.name,
6699            'port': self.port,
6700            'port_override': self.port_override,
6701            'secret_store_id': self.secret_store_id,
6702            'tags': self.tags,
6703            'token': self.token,
6704        }
@classmethod
def from_dict(cls, d)
6706    @classmethod
6707    def from_dict(cls, d):
6708        return cls(
6709            bind_interface=d.get('bind_interface'),
6710            egress_filter=d.get('egress_filter'),
6711            healthcheck_namespace=d.get('healthcheck_namespace'),
6712            healthy=d.get('healthy'),
6713            hostname=d.get('hostname'),
6714            id=d.get('id'),
6715            name=d.get('name'),
6716            port=d.get('port'),
6717            port_override=d.get('port_override'),
6718            secret_store_id=d.get('secret_store_id'),
6719            tags=d.get('tags'),
6720            token=d.get('token'),
6721        )
class KubernetesUserImpersonation:
6724class KubernetesUserImpersonation:
6725    __slots__ = [
6726        'bind_interface',
6727        'certificate_authority',
6728        'client_certificate',
6729        'client_key',
6730        'egress_filter',
6731        'healthcheck_namespace',
6732        'healthy',
6733        'hostname',
6734        'id',
6735        'name',
6736        'port',
6737        'port_override',
6738        'secret_store_id',
6739        'tags',
6740    ]
6741
6742    def __init__(
6743        self,
6744        bind_interface=None,
6745        certificate_authority=None,
6746        client_certificate=None,
6747        client_key=None,
6748        egress_filter=None,
6749        healthcheck_namespace=None,
6750        healthy=None,
6751        hostname=None,
6752        id=None,
6753        name=None,
6754        port=None,
6755        port_override=None,
6756        secret_store_id=None,
6757        tags=None,
6758    ):
6759        self.bind_interface = bind_interface if bind_interface is not None else ''
6760        '''
6761         Bind interface
6762        '''
6763        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6764        self.client_certificate = client_certificate if client_certificate is not None else ''
6765        self.client_key = client_key if client_key is not None else ''
6766        self.egress_filter = egress_filter if egress_filter is not None else ''
6767        '''
6768         A filter applied to the routing logic to pin datasource to nodes.
6769        '''
6770        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6771        '''
6772         The path used to check the health of your connection.  Defaults to `default`.
6773        '''
6774        self.healthy = healthy if healthy is not None else False
6775        '''
6776         True if the datasource is reachable and the credentials are valid.
6777        '''
6778        self.hostname = hostname if hostname is not None else ''
6779        self.id = id if id is not None else ''
6780        '''
6781         Unique identifier of the Resource.
6782        '''
6783        self.name = name if name is not None else ''
6784        '''
6785         Unique human-readable name of the Resource.
6786        '''
6787        self.port = port if port is not None else 0
6788        self.port_override = port_override if port_override is not None else 0
6789        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6790        '''
6791         ID of the secret store containing credentials for this resource, if any.
6792        '''
6793        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6794        '''
6795         Tags is a map of key, value pairs.
6796        '''
6797
6798    def __repr__(self):
6799        return '<sdm.KubernetesUserImpersonation ' + \
6800            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6801            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6802            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6803            'client_key: ' + repr(self.client_key) + ' ' +\
6804            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6805            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6806            'healthy: ' + repr(self.healthy) + ' ' +\
6807            'hostname: ' + repr(self.hostname) + ' ' +\
6808            'id: ' + repr(self.id) + ' ' +\
6809            'name: ' + repr(self.name) + ' ' +\
6810            'port: ' + repr(self.port) + ' ' +\
6811            'port_override: ' + repr(self.port_override) + ' ' +\
6812            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6813            'tags: ' + repr(self.tags) + ' ' +\
6814            '>'
6815
6816    def to_dict(self):
6817        return {
6818            'bind_interface': self.bind_interface,
6819            'certificate_authority': self.certificate_authority,
6820            'client_certificate': self.client_certificate,
6821            'client_key': self.client_key,
6822            'egress_filter': self.egress_filter,
6823            'healthcheck_namespace': self.healthcheck_namespace,
6824            'healthy': self.healthy,
6825            'hostname': self.hostname,
6826            'id': self.id,
6827            'name': self.name,
6828            'port': self.port,
6829            'port_override': self.port_override,
6830            'secret_store_id': self.secret_store_id,
6831            'tags': self.tags,
6832        }
6833
6834    @classmethod
6835    def from_dict(cls, d):
6836        return cls(
6837            bind_interface=d.get('bind_interface'),
6838            certificate_authority=d.get('certificate_authority'),
6839            client_certificate=d.get('client_certificate'),
6840            client_key=d.get('client_key'),
6841            egress_filter=d.get('egress_filter'),
6842            healthcheck_namespace=d.get('healthcheck_namespace'),
6843            healthy=d.get('healthy'),
6844            hostname=d.get('hostname'),
6845            id=d.get('id'),
6846            name=d.get('name'),
6847            port=d.get('port'),
6848            port_override=d.get('port_override'),
6849            secret_store_id=d.get('secret_store_id'),
6850            tags=d.get('tags'),
6851        )
KubernetesUserImpersonation( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
6742    def __init__(
6743        self,
6744        bind_interface=None,
6745        certificate_authority=None,
6746        client_certificate=None,
6747        client_key=None,
6748        egress_filter=None,
6749        healthcheck_namespace=None,
6750        healthy=None,
6751        hostname=None,
6752        id=None,
6753        name=None,
6754        port=None,
6755        port_override=None,
6756        secret_store_id=None,
6757        tags=None,
6758    ):
6759        self.bind_interface = bind_interface if bind_interface is not None else ''
6760        '''
6761         Bind interface
6762        '''
6763        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6764        self.client_certificate = client_certificate if client_certificate is not None else ''
6765        self.client_key = client_key if client_key is not None else ''
6766        self.egress_filter = egress_filter if egress_filter is not None else ''
6767        '''
6768         A filter applied to the routing logic to pin datasource to nodes.
6769        '''
6770        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6771        '''
6772         The path used to check the health of your connection.  Defaults to `default`.
6773        '''
6774        self.healthy = healthy if healthy is not None else False
6775        '''
6776         True if the datasource is reachable and the credentials are valid.
6777        '''
6778        self.hostname = hostname if hostname is not None else ''
6779        self.id = id if id is not None else ''
6780        '''
6781         Unique identifier of the Resource.
6782        '''
6783        self.name = name if name is not None else ''
6784        '''
6785         Unique human-readable name of the Resource.
6786        '''
6787        self.port = port if port is not None else 0
6788        self.port_override = port_override if port_override is not None else 0
6789        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6790        '''
6791         ID of the secret store containing credentials for this resource, if any.
6792        '''
6793        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6794        '''
6795         Tags is a map of key, value pairs.
6796        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
6816    def to_dict(self):
6817        return {
6818            'bind_interface': self.bind_interface,
6819            'certificate_authority': self.certificate_authority,
6820            'client_certificate': self.client_certificate,
6821            'client_key': self.client_key,
6822            'egress_filter': self.egress_filter,
6823            'healthcheck_namespace': self.healthcheck_namespace,
6824            'healthy': self.healthy,
6825            'hostname': self.hostname,
6826            'id': self.id,
6827            'name': self.name,
6828            'port': self.port,
6829            'port_override': self.port_override,
6830            'secret_store_id': self.secret_store_id,
6831            'tags': self.tags,
6832        }
@classmethod
def from_dict(cls, d)
6834    @classmethod
6835    def from_dict(cls, d):
6836        return cls(
6837            bind_interface=d.get('bind_interface'),
6838            certificate_authority=d.get('certificate_authority'),
6839            client_certificate=d.get('client_certificate'),
6840            client_key=d.get('client_key'),
6841            egress_filter=d.get('egress_filter'),
6842            healthcheck_namespace=d.get('healthcheck_namespace'),
6843            healthy=d.get('healthy'),
6844            hostname=d.get('hostname'),
6845            id=d.get('id'),
6846            name=d.get('name'),
6847            port=d.get('port'),
6848            port_override=d.get('port_override'),
6849            secret_store_id=d.get('secret_store_id'),
6850            tags=d.get('tags'),
6851        )
class MTLSMysql:
6854class MTLSMysql:
6855    '''
6856    MTLSMysql is currently unstable, and its API may change, or it may be removed,
6857    without a major version bump.
6858    '''
6859    __slots__ = [
6860        'bind_interface',
6861        'certificate_authority',
6862        'client_certificate',
6863        'client_key',
6864        'database',
6865        'egress_filter',
6866        'healthy',
6867        'hostname',
6868        'id',
6869        'name',
6870        'password',
6871        'port',
6872        'port_override',
6873        'secret_store_id',
6874        'server_name',
6875        'tags',
6876        'username',
6877    ]
6878
6879    def __init__(
6880        self,
6881        bind_interface=None,
6882        certificate_authority=None,
6883        client_certificate=None,
6884        client_key=None,
6885        database=None,
6886        egress_filter=None,
6887        healthy=None,
6888        hostname=None,
6889        id=None,
6890        name=None,
6891        password=None,
6892        port=None,
6893        port_override=None,
6894        secret_store_id=None,
6895        server_name=None,
6896        tags=None,
6897        username=None,
6898    ):
6899        self.bind_interface = bind_interface if bind_interface is not None else ''
6900        '''
6901         Bind interface
6902        '''
6903        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6904        self.client_certificate = client_certificate if client_certificate is not None else ''
6905        self.client_key = client_key if client_key is not None else ''
6906        self.database = database if database is not None else ''
6907        self.egress_filter = egress_filter if egress_filter is not None else ''
6908        '''
6909         A filter applied to the routing logic to pin datasource to nodes.
6910        '''
6911        self.healthy = healthy if healthy is not None else False
6912        '''
6913         True if the datasource is reachable and the credentials are valid.
6914        '''
6915        self.hostname = hostname if hostname is not None else ''
6916        self.id = id if id is not None else ''
6917        '''
6918         Unique identifier of the Resource.
6919        '''
6920        self.name = name if name is not None else ''
6921        '''
6922         Unique human-readable name of the Resource.
6923        '''
6924        self.password = password if password is not None else ''
6925        self.port = port if port is not None else 0
6926        self.port_override = port_override if port_override is not None else 0
6927        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6928        '''
6929         ID of the secret store containing credentials for this resource, if any.
6930        '''
6931        self.server_name = server_name if server_name is not None else ''
6932        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6933        '''
6934         Tags is a map of key, value pairs.
6935        '''
6936        self.username = username if username is not None else ''
6937
6938    def __repr__(self):
6939        return '<sdm.MTLSMysql ' + \
6940            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6941            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6942            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6943            'client_key: ' + repr(self.client_key) + ' ' +\
6944            'database: ' + repr(self.database) + ' ' +\
6945            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6946            'healthy: ' + repr(self.healthy) + ' ' +\
6947            'hostname: ' + repr(self.hostname) + ' ' +\
6948            'id: ' + repr(self.id) + ' ' +\
6949            'name: ' + repr(self.name) + ' ' +\
6950            'password: ' + repr(self.password) + ' ' +\
6951            'port: ' + repr(self.port) + ' ' +\
6952            'port_override: ' + repr(self.port_override) + ' ' +\
6953            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6954            'server_name: ' + repr(self.server_name) + ' ' +\
6955            'tags: ' + repr(self.tags) + ' ' +\
6956            'username: ' + repr(self.username) + ' ' +\
6957            '>'
6958
6959    def to_dict(self):
6960        return {
6961            'bind_interface': self.bind_interface,
6962            'certificate_authority': self.certificate_authority,
6963            'client_certificate': self.client_certificate,
6964            'client_key': self.client_key,
6965            'database': self.database,
6966            'egress_filter': self.egress_filter,
6967            'healthy': self.healthy,
6968            'hostname': self.hostname,
6969            'id': self.id,
6970            'name': self.name,
6971            'password': self.password,
6972            'port': self.port,
6973            'port_override': self.port_override,
6974            'secret_store_id': self.secret_store_id,
6975            'server_name': self.server_name,
6976            'tags': self.tags,
6977            'username': self.username,
6978        }
6979
6980    @classmethod
6981    def from_dict(cls, d):
6982        return cls(
6983            bind_interface=d.get('bind_interface'),
6984            certificate_authority=d.get('certificate_authority'),
6985            client_certificate=d.get('client_certificate'),
6986            client_key=d.get('client_key'),
6987            database=d.get('database'),
6988            egress_filter=d.get('egress_filter'),
6989            healthy=d.get('healthy'),
6990            hostname=d.get('hostname'),
6991            id=d.get('id'),
6992            name=d.get('name'),
6993            password=d.get('password'),
6994            port=d.get('port'),
6995            port_override=d.get('port_override'),
6996            secret_store_id=d.get('secret_store_id'),
6997            server_name=d.get('server_name'),
6998            tags=d.get('tags'),
6999            username=d.get('username'),
7000        )

MTLSMysql is currently unstable, and its API may change, or it may be removed, without a major version bump.

MTLSMysql( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None)
6879    def __init__(
6880        self,
6881        bind_interface=None,
6882        certificate_authority=None,
6883        client_certificate=None,
6884        client_key=None,
6885        database=None,
6886        egress_filter=None,
6887        healthy=None,
6888        hostname=None,
6889        id=None,
6890        name=None,
6891        password=None,
6892        port=None,
6893        port_override=None,
6894        secret_store_id=None,
6895        server_name=None,
6896        tags=None,
6897        username=None,
6898    ):
6899        self.bind_interface = bind_interface if bind_interface is not None else ''
6900        '''
6901         Bind interface
6902        '''
6903        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6904        self.client_certificate = client_certificate if client_certificate is not None else ''
6905        self.client_key = client_key if client_key is not None else ''
6906        self.database = database if database is not None else ''
6907        self.egress_filter = egress_filter if egress_filter is not None else ''
6908        '''
6909         A filter applied to the routing logic to pin datasource to nodes.
6910        '''
6911        self.healthy = healthy if healthy is not None else False
6912        '''
6913         True if the datasource is reachable and the credentials are valid.
6914        '''
6915        self.hostname = hostname if hostname is not None else ''
6916        self.id = id if id is not None else ''
6917        '''
6918         Unique identifier of the Resource.
6919        '''
6920        self.name = name if name is not None else ''
6921        '''
6922         Unique human-readable name of the Resource.
6923        '''
6924        self.password = password if password is not None else ''
6925        self.port = port if port is not None else 0
6926        self.port_override = port_override if port_override is not None else 0
6927        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6928        '''
6929         ID of the secret store containing credentials for this resource, if any.
6930        '''
6931        self.server_name = server_name if server_name is not None else ''
6932        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6933        '''
6934         Tags is a map of key, value pairs.
6935        '''
6936        self.username = username if username is not None else ''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

server_name
tags

Tags is a map of key, value pairs.

username
def to_dict(self)
6959    def to_dict(self):
6960        return {
6961            'bind_interface': self.bind_interface,
6962            'certificate_authority': self.certificate_authority,
6963            'client_certificate': self.client_certificate,
6964            'client_key': self.client_key,
6965            'database': self.database,
6966            'egress_filter': self.egress_filter,
6967            'healthy': self.healthy,
6968            'hostname': self.hostname,
6969            'id': self.id,
6970            'name': self.name,
6971            'password': self.password,
6972            'port': self.port,
6973            'port_override': self.port_override,
6974            'secret_store_id': self.secret_store_id,
6975            'server_name': self.server_name,
6976            'tags': self.tags,
6977            'username': self.username,
6978        }
@classmethod
def from_dict(cls, d)
6980    @classmethod
6981    def from_dict(cls, d):
6982        return cls(
6983            bind_interface=d.get('bind_interface'),
6984            certificate_authority=d.get('certificate_authority'),
6985            client_certificate=d.get('client_certificate'),
6986            client_key=d.get('client_key'),
6987            database=d.get('database'),
6988            egress_filter=d.get('egress_filter'),
6989            healthy=d.get('healthy'),
6990            hostname=d.get('hostname'),
6991            id=d.get('id'),
6992            name=d.get('name'),
6993            password=d.get('password'),
6994            port=d.get('port'),
6995            port_override=d.get('port_override'),
6996            secret_store_id=d.get('secret_store_id'),
6997            server_name=d.get('server_name'),
6998            tags=d.get('tags'),
6999            username=d.get('username'),
7000        )
class MTLSPostgres:
7003class MTLSPostgres:
7004    __slots__ = [
7005        'bind_interface',
7006        'certificate_authority',
7007        'client_certificate',
7008        'client_key',
7009        'database',
7010        'egress_filter',
7011        'healthy',
7012        'hostname',
7013        'id',
7014        'name',
7015        'override_database',
7016        'password',
7017        'port',
7018        'port_override',
7019        'secret_store_id',
7020        'server_name',
7021        'tags',
7022        'username',
7023    ]
7024
7025    def __init__(
7026        self,
7027        bind_interface=None,
7028        certificate_authority=None,
7029        client_certificate=None,
7030        client_key=None,
7031        database=None,
7032        egress_filter=None,
7033        healthy=None,
7034        hostname=None,
7035        id=None,
7036        name=None,
7037        override_database=None,
7038        password=None,
7039        port=None,
7040        port_override=None,
7041        secret_store_id=None,
7042        server_name=None,
7043        tags=None,
7044        username=None,
7045    ):
7046        self.bind_interface = bind_interface if bind_interface is not None else ''
7047        '''
7048         Bind interface
7049        '''
7050        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
7051        self.client_certificate = client_certificate if client_certificate is not None else ''
7052        self.client_key = client_key if client_key is not None else ''
7053        self.database = database if database is not None else ''
7054        self.egress_filter = egress_filter if egress_filter is not None else ''
7055        '''
7056         A filter applied to the routing logic to pin datasource to nodes.
7057        '''
7058        self.healthy = healthy if healthy is not None else False
7059        '''
7060         True if the datasource is reachable and the credentials are valid.
7061        '''
7062        self.hostname = hostname if hostname is not None else ''
7063        self.id = id if id is not None else ''
7064        '''
7065         Unique identifier of the Resource.
7066        '''
7067        self.name = name if name is not None else ''
7068        '''
7069         Unique human-readable name of the Resource.
7070        '''
7071        self.override_database = override_database if override_database is not None else False
7072        self.password = password if password is not None else ''
7073        self.port = port if port is not None else 0
7074        self.port_override = port_override if port_override is not None else 0
7075        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7076        '''
7077         ID of the secret store containing credentials for this resource, if any.
7078        '''
7079        self.server_name = server_name if server_name is not None else ''
7080        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7081        '''
7082         Tags is a map of key, value pairs.
7083        '''
7084        self.username = username if username is not None else ''
7085
7086    def __repr__(self):
7087        return '<sdm.MTLSPostgres ' + \
7088            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7089            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
7090            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
7091            'client_key: ' + repr(self.client_key) + ' ' +\
7092            'database: ' + repr(self.database) + ' ' +\
7093            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7094            'healthy: ' + repr(self.healthy) + ' ' +\
7095            'hostname: ' + repr(self.hostname) + ' ' +\
7096            'id: ' + repr(self.id) + ' ' +\
7097            'name: ' + repr(self.name) + ' ' +\
7098            'override_database: ' + repr(self.override_database) + ' ' +\
7099            'password: ' + repr(self.password) + ' ' +\
7100            'port: ' + repr(self.port) + ' ' +\
7101            'port_override: ' + repr(self.port_override) + ' ' +\
7102            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7103            'server_name: ' + repr(self.server_name) + ' ' +\
7104            'tags: ' + repr(self.tags) + ' ' +\
7105            'username: ' + repr(self.username) + ' ' +\
7106            '>'
7107
7108    def to_dict(self):
7109        return {
7110            'bind_interface': self.bind_interface,
7111            'certificate_authority': self.certificate_authority,
7112            'client_certificate': self.client_certificate,
7113            'client_key': self.client_key,
7114            'database': self.database,
7115            'egress_filter': self.egress_filter,
7116            'healthy': self.healthy,
7117            'hostname': self.hostname,
7118            'id': self.id,
7119            'name': self.name,
7120            'override_database': self.override_database,
7121            'password': self.password,
7122            'port': self.port,
7123            'port_override': self.port_override,
7124            'secret_store_id': self.secret_store_id,
7125            'server_name': self.server_name,
7126            'tags': self.tags,
7127            'username': self.username,
7128        }
7129
7130    @classmethod
7131    def from_dict(cls, d):
7132        return cls(
7133            bind_interface=d.get('bind_interface'),
7134            certificate_authority=d.get('certificate_authority'),
7135            client_certificate=d.get('client_certificate'),
7136            client_key=d.get('client_key'),
7137            database=d.get('database'),
7138            egress_filter=d.get('egress_filter'),
7139            healthy=d.get('healthy'),
7140            hostname=d.get('hostname'),
7141            id=d.get('id'),
7142            name=d.get('name'),
7143            override_database=d.get('override_database'),
7144            password=d.get('password'),
7145            port=d.get('port'),
7146            port_override=d.get('port_override'),
7147            secret_store_id=d.get('secret_store_id'),
7148            server_name=d.get('server_name'),
7149            tags=d.get('tags'),
7150            username=d.get('username'),
7151        )
MTLSPostgres( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None)
7025    def __init__(
7026        self,
7027        bind_interface=None,
7028        certificate_authority=None,
7029        client_certificate=None,
7030        client_key=None,
7031        database=None,
7032        egress_filter=None,
7033        healthy=None,
7034        hostname=None,
7035        id=None,
7036        name=None,
7037        override_database=None,
7038        password=None,
7039        port=None,
7040        port_override=None,
7041        secret_store_id=None,
7042        server_name=None,
7043        tags=None,
7044        username=None,
7045    ):
7046        self.bind_interface = bind_interface if bind_interface is not None else ''
7047        '''
7048         Bind interface
7049        '''
7050        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
7051        self.client_certificate = client_certificate if client_certificate is not None else ''
7052        self.client_key = client_key if client_key is not None else ''
7053        self.database = database if database is not None else ''
7054        self.egress_filter = egress_filter if egress_filter is not None else ''
7055        '''
7056         A filter applied to the routing logic to pin datasource to nodes.
7057        '''
7058        self.healthy = healthy if healthy is not None else False
7059        '''
7060         True if the datasource is reachable and the credentials are valid.
7061        '''
7062        self.hostname = hostname if hostname is not None else ''
7063        self.id = id if id is not None else ''
7064        '''
7065         Unique identifier of the Resource.
7066        '''
7067        self.name = name if name is not None else ''
7068        '''
7069         Unique human-readable name of the Resource.
7070        '''
7071        self.override_database = override_database if override_database is not None else False
7072        self.password = password if password is not None else ''
7073        self.port = port if port is not None else 0
7074        self.port_override = port_override if port_override is not None else 0
7075        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7076        '''
7077         ID of the secret store containing credentials for this resource, if any.
7078        '''
7079        self.server_name = server_name if server_name is not None else ''
7080        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7081        '''
7082         Tags is a map of key, value pairs.
7083        '''
7084        self.username = username if username is not None else ''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

server_name
tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7108    def to_dict(self):
7109        return {
7110            'bind_interface': self.bind_interface,
7111            'certificate_authority': self.certificate_authority,
7112            'client_certificate': self.client_certificate,
7113            'client_key': self.client_key,
7114            'database': self.database,
7115            'egress_filter': self.egress_filter,
7116            'healthy': self.healthy,
7117            'hostname': self.hostname,
7118            'id': self.id,
7119            'name': self.name,
7120            'override_database': self.override_database,
7121            'password': self.password,
7122            'port': self.port,
7123            'port_override': self.port_override,
7124            'secret_store_id': self.secret_store_id,
7125            'server_name': self.server_name,
7126            'tags': self.tags,
7127            'username': self.username,
7128        }
@classmethod
def from_dict(cls, d)
7130    @classmethod
7131    def from_dict(cls, d):
7132        return cls(
7133            bind_interface=d.get('bind_interface'),
7134            certificate_authority=d.get('certificate_authority'),
7135            client_certificate=d.get('client_certificate'),
7136            client_key=d.get('client_key'),
7137            database=d.get('database'),
7138            egress_filter=d.get('egress_filter'),
7139            healthy=d.get('healthy'),
7140            hostname=d.get('hostname'),
7141            id=d.get('id'),
7142            name=d.get('name'),
7143            override_database=d.get('override_database'),
7144            password=d.get('password'),
7145            port=d.get('port'),
7146            port_override=d.get('port_override'),
7147            secret_store_id=d.get('secret_store_id'),
7148            server_name=d.get('server_name'),
7149            tags=d.get('tags'),
7150            username=d.get('username'),
7151        )
class Maria:
7154class Maria:
7155    __slots__ = [
7156        'bind_interface',
7157        'database',
7158        'egress_filter',
7159        'healthy',
7160        'hostname',
7161        'id',
7162        'name',
7163        'password',
7164        'port',
7165        'port_override',
7166        'secret_store_id',
7167        'tags',
7168        'username',
7169    ]
7170
7171    def __init__(
7172        self,
7173        bind_interface=None,
7174        database=None,
7175        egress_filter=None,
7176        healthy=None,
7177        hostname=None,
7178        id=None,
7179        name=None,
7180        password=None,
7181        port=None,
7182        port_override=None,
7183        secret_store_id=None,
7184        tags=None,
7185        username=None,
7186    ):
7187        self.bind_interface = bind_interface if bind_interface is not None else ''
7188        '''
7189         Bind interface
7190        '''
7191        self.database = database if database is not None else ''
7192        self.egress_filter = egress_filter if egress_filter is not None else ''
7193        '''
7194         A filter applied to the routing logic to pin datasource to nodes.
7195        '''
7196        self.healthy = healthy if healthy is not None else False
7197        '''
7198         True if the datasource is reachable and the credentials are valid.
7199        '''
7200        self.hostname = hostname if hostname is not None else ''
7201        self.id = id if id is not None else ''
7202        '''
7203         Unique identifier of the Resource.
7204        '''
7205        self.name = name if name is not None else ''
7206        '''
7207         Unique human-readable name of the Resource.
7208        '''
7209        self.password = password if password is not None else ''
7210        self.port = port if port is not None else 0
7211        self.port_override = port_override if port_override is not None else 0
7212        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7213        '''
7214         ID of the secret store containing credentials for this resource, if any.
7215        '''
7216        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7217        '''
7218         Tags is a map of key, value pairs.
7219        '''
7220        self.username = username if username is not None else ''
7221
7222    def __repr__(self):
7223        return '<sdm.Maria ' + \
7224            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7225            'database: ' + repr(self.database) + ' ' +\
7226            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7227            'healthy: ' + repr(self.healthy) + ' ' +\
7228            'hostname: ' + repr(self.hostname) + ' ' +\
7229            'id: ' + repr(self.id) + ' ' +\
7230            'name: ' + repr(self.name) + ' ' +\
7231            'password: ' + repr(self.password) + ' ' +\
7232            'port: ' + repr(self.port) + ' ' +\
7233            'port_override: ' + repr(self.port_override) + ' ' +\
7234            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7235            'tags: ' + repr(self.tags) + ' ' +\
7236            'username: ' + repr(self.username) + ' ' +\
7237            '>'
7238
7239    def to_dict(self):
7240        return {
7241            'bind_interface': self.bind_interface,
7242            'database': self.database,
7243            'egress_filter': self.egress_filter,
7244            'healthy': self.healthy,
7245            'hostname': self.hostname,
7246            'id': self.id,
7247            'name': self.name,
7248            'password': self.password,
7249            'port': self.port,
7250            'port_override': self.port_override,
7251            'secret_store_id': self.secret_store_id,
7252            'tags': self.tags,
7253            'username': self.username,
7254        }
7255
7256    @classmethod
7257    def from_dict(cls, d):
7258        return cls(
7259            bind_interface=d.get('bind_interface'),
7260            database=d.get('database'),
7261            egress_filter=d.get('egress_filter'),
7262            healthy=d.get('healthy'),
7263            hostname=d.get('hostname'),
7264            id=d.get('id'),
7265            name=d.get('name'),
7266            password=d.get('password'),
7267            port=d.get('port'),
7268            port_override=d.get('port_override'),
7269            secret_store_id=d.get('secret_store_id'),
7270            tags=d.get('tags'),
7271            username=d.get('username'),
7272        )
Maria( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
7171    def __init__(
7172        self,
7173        bind_interface=None,
7174        database=None,
7175        egress_filter=None,
7176        healthy=None,
7177        hostname=None,
7178        id=None,
7179        name=None,
7180        password=None,
7181        port=None,
7182        port_override=None,
7183        secret_store_id=None,
7184        tags=None,
7185        username=None,
7186    ):
7187        self.bind_interface = bind_interface if bind_interface is not None else ''
7188        '''
7189         Bind interface
7190        '''
7191        self.database = database if database is not None else ''
7192        self.egress_filter = egress_filter if egress_filter is not None else ''
7193        '''
7194         A filter applied to the routing logic to pin datasource to nodes.
7195        '''
7196        self.healthy = healthy if healthy is not None else False
7197        '''
7198         True if the datasource is reachable and the credentials are valid.
7199        '''
7200        self.hostname = hostname if hostname is not None else ''
7201        self.id = id if id is not None else ''
7202        '''
7203         Unique identifier of the Resource.
7204        '''
7205        self.name = name if name is not None else ''
7206        '''
7207         Unique human-readable name of the Resource.
7208        '''
7209        self.password = password if password is not None else ''
7210        self.port = port if port is not None else 0
7211        self.port_override = port_override if port_override is not None else 0
7212        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7213        '''
7214         ID of the secret store containing credentials for this resource, if any.
7215        '''
7216        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7217        '''
7218         Tags is a map of key, value pairs.
7219        '''
7220        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7239    def to_dict(self):
7240        return {
7241            'bind_interface': self.bind_interface,
7242            'database': self.database,
7243            'egress_filter': self.egress_filter,
7244            'healthy': self.healthy,
7245            'hostname': self.hostname,
7246            'id': self.id,
7247            'name': self.name,
7248            'password': self.password,
7249            'port': self.port,
7250            'port_override': self.port_override,
7251            'secret_store_id': self.secret_store_id,
7252            'tags': self.tags,
7253            'username': self.username,
7254        }
@classmethod
def from_dict(cls, d)
7256    @classmethod
7257    def from_dict(cls, d):
7258        return cls(
7259            bind_interface=d.get('bind_interface'),
7260            database=d.get('database'),
7261            egress_filter=d.get('egress_filter'),
7262            healthy=d.get('healthy'),
7263            hostname=d.get('hostname'),
7264            id=d.get('id'),
7265            name=d.get('name'),
7266            password=d.get('password'),
7267            port=d.get('port'),
7268            port_override=d.get('port_override'),
7269            secret_store_id=d.get('secret_store_id'),
7270            tags=d.get('tags'),
7271            username=d.get('username'),
7272        )
class Memcached:
7275class Memcached:
7276    __slots__ = [
7277        'bind_interface',
7278        'egress_filter',
7279        'healthy',
7280        'hostname',
7281        'id',
7282        'name',
7283        'port',
7284        'port_override',
7285        'secret_store_id',
7286        'tags',
7287    ]
7288
7289    def __init__(
7290        self,
7291        bind_interface=None,
7292        egress_filter=None,
7293        healthy=None,
7294        hostname=None,
7295        id=None,
7296        name=None,
7297        port=None,
7298        port_override=None,
7299        secret_store_id=None,
7300        tags=None,
7301    ):
7302        self.bind_interface = bind_interface if bind_interface is not None else ''
7303        '''
7304         Bind interface
7305        '''
7306        self.egress_filter = egress_filter if egress_filter is not None else ''
7307        '''
7308         A filter applied to the routing logic to pin datasource to nodes.
7309        '''
7310        self.healthy = healthy if healthy is not None else False
7311        '''
7312         True if the datasource is reachable and the credentials are valid.
7313        '''
7314        self.hostname = hostname if hostname is not None else ''
7315        self.id = id if id is not None else ''
7316        '''
7317         Unique identifier of the Resource.
7318        '''
7319        self.name = name if name is not None else ''
7320        '''
7321         Unique human-readable name of the Resource.
7322        '''
7323        self.port = port if port is not None else 0
7324        self.port_override = port_override if port_override is not None else 0
7325        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7326        '''
7327         ID of the secret store containing credentials for this resource, if any.
7328        '''
7329        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7330        '''
7331         Tags is a map of key, value pairs.
7332        '''
7333
7334    def __repr__(self):
7335        return '<sdm.Memcached ' + \
7336            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7337            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7338            'healthy: ' + repr(self.healthy) + ' ' +\
7339            'hostname: ' + repr(self.hostname) + ' ' +\
7340            'id: ' + repr(self.id) + ' ' +\
7341            'name: ' + repr(self.name) + ' ' +\
7342            'port: ' + repr(self.port) + ' ' +\
7343            'port_override: ' + repr(self.port_override) + ' ' +\
7344            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7345            'tags: ' + repr(self.tags) + ' ' +\
7346            '>'
7347
7348    def to_dict(self):
7349        return {
7350            'bind_interface': self.bind_interface,
7351            'egress_filter': self.egress_filter,
7352            'healthy': self.healthy,
7353            'hostname': self.hostname,
7354            'id': self.id,
7355            'name': self.name,
7356            'port': self.port,
7357            'port_override': self.port_override,
7358            'secret_store_id': self.secret_store_id,
7359            'tags': self.tags,
7360        }
7361
7362    @classmethod
7363    def from_dict(cls, d):
7364        return cls(
7365            bind_interface=d.get('bind_interface'),
7366            egress_filter=d.get('egress_filter'),
7367            healthy=d.get('healthy'),
7368            hostname=d.get('hostname'),
7369            id=d.get('id'),
7370            name=d.get('name'),
7371            port=d.get('port'),
7372            port_override=d.get('port_override'),
7373            secret_store_id=d.get('secret_store_id'),
7374            tags=d.get('tags'),
7375        )
Memcached( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
7289    def __init__(
7290        self,
7291        bind_interface=None,
7292        egress_filter=None,
7293        healthy=None,
7294        hostname=None,
7295        id=None,
7296        name=None,
7297        port=None,
7298        port_override=None,
7299        secret_store_id=None,
7300        tags=None,
7301    ):
7302        self.bind_interface = bind_interface if bind_interface is not None else ''
7303        '''
7304         Bind interface
7305        '''
7306        self.egress_filter = egress_filter if egress_filter is not None else ''
7307        '''
7308         A filter applied to the routing logic to pin datasource to nodes.
7309        '''
7310        self.healthy = healthy if healthy is not None else False
7311        '''
7312         True if the datasource is reachable and the credentials are valid.
7313        '''
7314        self.hostname = hostname if hostname is not None else ''
7315        self.id = id if id is not None else ''
7316        '''
7317         Unique identifier of the Resource.
7318        '''
7319        self.name = name if name is not None else ''
7320        '''
7321         Unique human-readable name of the Resource.
7322        '''
7323        self.port = port if port is not None else 0
7324        self.port_override = port_override if port_override is not None else 0
7325        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7326        '''
7327         ID of the secret store containing credentials for this resource, if any.
7328        '''
7329        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7330        '''
7331         Tags is a map of key, value pairs.
7332        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
7348    def to_dict(self):
7349        return {
7350            'bind_interface': self.bind_interface,
7351            'egress_filter': self.egress_filter,
7352            'healthy': self.healthy,
7353            'hostname': self.hostname,
7354            'id': self.id,
7355            'name': self.name,
7356            'port': self.port,
7357            'port_override': self.port_override,
7358            'secret_store_id': self.secret_store_id,
7359            'tags': self.tags,
7360        }
@classmethod
def from_dict(cls, d)
7362    @classmethod
7363    def from_dict(cls, d):
7364        return cls(
7365            bind_interface=d.get('bind_interface'),
7366            egress_filter=d.get('egress_filter'),
7367            healthy=d.get('healthy'),
7368            hostname=d.get('hostname'),
7369            id=d.get('id'),
7370            name=d.get('name'),
7371            port=d.get('port'),
7372            port_override=d.get('port_override'),
7373            secret_store_id=d.get('secret_store_id'),
7374            tags=d.get('tags'),
7375        )
class Memsql:
7378class Memsql:
7379    __slots__ = [
7380        'bind_interface',
7381        'database',
7382        'egress_filter',
7383        'healthy',
7384        'hostname',
7385        'id',
7386        'name',
7387        'password',
7388        'port',
7389        'port_override',
7390        'secret_store_id',
7391        'tags',
7392        'username',
7393    ]
7394
7395    def __init__(
7396        self,
7397        bind_interface=None,
7398        database=None,
7399        egress_filter=None,
7400        healthy=None,
7401        hostname=None,
7402        id=None,
7403        name=None,
7404        password=None,
7405        port=None,
7406        port_override=None,
7407        secret_store_id=None,
7408        tags=None,
7409        username=None,
7410    ):
7411        self.bind_interface = bind_interface if bind_interface is not None else ''
7412        '''
7413         Bind interface
7414        '''
7415        self.database = database if database is not None else ''
7416        self.egress_filter = egress_filter if egress_filter is not None else ''
7417        '''
7418         A filter applied to the routing logic to pin datasource to nodes.
7419        '''
7420        self.healthy = healthy if healthy is not None else False
7421        '''
7422         True if the datasource is reachable and the credentials are valid.
7423        '''
7424        self.hostname = hostname if hostname is not None else ''
7425        self.id = id if id is not None else ''
7426        '''
7427         Unique identifier of the Resource.
7428        '''
7429        self.name = name if name is not None else ''
7430        '''
7431         Unique human-readable name of the Resource.
7432        '''
7433        self.password = password if password is not None else ''
7434        self.port = port if port is not None else 0
7435        self.port_override = port_override if port_override is not None else 0
7436        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7437        '''
7438         ID of the secret store containing credentials for this resource, if any.
7439        '''
7440        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7441        '''
7442         Tags is a map of key, value pairs.
7443        '''
7444        self.username = username if username is not None else ''
7445
7446    def __repr__(self):
7447        return '<sdm.Memsql ' + \
7448            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7449            'database: ' + repr(self.database) + ' ' +\
7450            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7451            'healthy: ' + repr(self.healthy) + ' ' +\
7452            'hostname: ' + repr(self.hostname) + ' ' +\
7453            'id: ' + repr(self.id) + ' ' +\
7454            'name: ' + repr(self.name) + ' ' +\
7455            'password: ' + repr(self.password) + ' ' +\
7456            'port: ' + repr(self.port) + ' ' +\
7457            'port_override: ' + repr(self.port_override) + ' ' +\
7458            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7459            'tags: ' + repr(self.tags) + ' ' +\
7460            'username: ' + repr(self.username) + ' ' +\
7461            '>'
7462
7463    def to_dict(self):
7464        return {
7465            'bind_interface': self.bind_interface,
7466            'database': self.database,
7467            'egress_filter': self.egress_filter,
7468            'healthy': self.healthy,
7469            'hostname': self.hostname,
7470            'id': self.id,
7471            'name': self.name,
7472            'password': self.password,
7473            'port': self.port,
7474            'port_override': self.port_override,
7475            'secret_store_id': self.secret_store_id,
7476            'tags': self.tags,
7477            'username': self.username,
7478        }
7479
7480    @classmethod
7481    def from_dict(cls, d):
7482        return cls(
7483            bind_interface=d.get('bind_interface'),
7484            database=d.get('database'),
7485            egress_filter=d.get('egress_filter'),
7486            healthy=d.get('healthy'),
7487            hostname=d.get('hostname'),
7488            id=d.get('id'),
7489            name=d.get('name'),
7490            password=d.get('password'),
7491            port=d.get('port'),
7492            port_override=d.get('port_override'),
7493            secret_store_id=d.get('secret_store_id'),
7494            tags=d.get('tags'),
7495            username=d.get('username'),
7496        )
Memsql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
7395    def __init__(
7396        self,
7397        bind_interface=None,
7398        database=None,
7399        egress_filter=None,
7400        healthy=None,
7401        hostname=None,
7402        id=None,
7403        name=None,
7404        password=None,
7405        port=None,
7406        port_override=None,
7407        secret_store_id=None,
7408        tags=None,
7409        username=None,
7410    ):
7411        self.bind_interface = bind_interface if bind_interface is not None else ''
7412        '''
7413         Bind interface
7414        '''
7415        self.database = database if database is not None else ''
7416        self.egress_filter = egress_filter if egress_filter is not None else ''
7417        '''
7418         A filter applied to the routing logic to pin datasource to nodes.
7419        '''
7420        self.healthy = healthy if healthy is not None else False
7421        '''
7422         True if the datasource is reachable and the credentials are valid.
7423        '''
7424        self.hostname = hostname if hostname is not None else ''
7425        self.id = id if id is not None else ''
7426        '''
7427         Unique identifier of the Resource.
7428        '''
7429        self.name = name if name is not None else ''
7430        '''
7431         Unique human-readable name of the Resource.
7432        '''
7433        self.password = password if password is not None else ''
7434        self.port = port if port is not None else 0
7435        self.port_override = port_override if port_override is not None else 0
7436        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7437        '''
7438         ID of the secret store containing credentials for this resource, if any.
7439        '''
7440        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7441        '''
7442         Tags is a map of key, value pairs.
7443        '''
7444        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7463    def to_dict(self):
7464        return {
7465            'bind_interface': self.bind_interface,
7466            'database': self.database,
7467            'egress_filter': self.egress_filter,
7468            'healthy': self.healthy,
7469            'hostname': self.hostname,
7470            'id': self.id,
7471            'name': self.name,
7472            'password': self.password,
7473            'port': self.port,
7474            'port_override': self.port_override,
7475            'secret_store_id': self.secret_store_id,
7476            'tags': self.tags,
7477            'username': self.username,
7478        }
@classmethod
def from_dict(cls, d)
7480    @classmethod
7481    def from_dict(cls, d):
7482        return cls(
7483            bind_interface=d.get('bind_interface'),
7484            database=d.get('database'),
7485            egress_filter=d.get('egress_filter'),
7486            healthy=d.get('healthy'),
7487            hostname=d.get('hostname'),
7488            id=d.get('id'),
7489            name=d.get('name'),
7490            password=d.get('password'),
7491            port=d.get('port'),
7492            port_override=d.get('port_override'),
7493            secret_store_id=d.get('secret_store_id'),
7494            tags=d.get('tags'),
7495            username=d.get('username'),
7496        )
class MongoHost:
7499class MongoHost:
7500    '''
7501    MongoHost is currently unstable, and its API may change, or it may be removed,
7502    without a major version bump.
7503    '''
7504    __slots__ = [
7505        'auth_database',
7506        'bind_interface',
7507        'egress_filter',
7508        'healthy',
7509        'hostname',
7510        'id',
7511        'name',
7512        'password',
7513        'port',
7514        'port_override',
7515        'secret_store_id',
7516        'tags',
7517        'tls_required',
7518        'username',
7519    ]
7520
7521    def __init__(
7522        self,
7523        auth_database=None,
7524        bind_interface=None,
7525        egress_filter=None,
7526        healthy=None,
7527        hostname=None,
7528        id=None,
7529        name=None,
7530        password=None,
7531        port=None,
7532        port_override=None,
7533        secret_store_id=None,
7534        tags=None,
7535        tls_required=None,
7536        username=None,
7537    ):
7538        self.auth_database = auth_database if auth_database is not None else ''
7539        self.bind_interface = bind_interface if bind_interface is not None else ''
7540        '''
7541         Bind interface
7542        '''
7543        self.egress_filter = egress_filter if egress_filter is not None else ''
7544        '''
7545         A filter applied to the routing logic to pin datasource to nodes.
7546        '''
7547        self.healthy = healthy if healthy is not None else False
7548        '''
7549         True if the datasource is reachable and the credentials are valid.
7550        '''
7551        self.hostname = hostname if hostname is not None else ''
7552        self.id = id if id is not None else ''
7553        '''
7554         Unique identifier of the Resource.
7555        '''
7556        self.name = name if name is not None else ''
7557        '''
7558         Unique human-readable name of the Resource.
7559        '''
7560        self.password = password if password is not None else ''
7561        self.port = port if port is not None else 0
7562        self.port_override = port_override if port_override is not None else 0
7563        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7564        '''
7565         ID of the secret store containing credentials for this resource, if any.
7566        '''
7567        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7568        '''
7569         Tags is a map of key, value pairs.
7570        '''
7571        self.tls_required = tls_required if tls_required is not None else False
7572        self.username = username if username is not None else ''
7573
7574    def __repr__(self):
7575        return '<sdm.MongoHost ' + \
7576            'auth_database: ' + repr(self.auth_database) + ' ' +\
7577            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7578            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7579            'healthy: ' + repr(self.healthy) + ' ' +\
7580            'hostname: ' + repr(self.hostname) + ' ' +\
7581            'id: ' + repr(self.id) + ' ' +\
7582            'name: ' + repr(self.name) + ' ' +\
7583            'password: ' + repr(self.password) + ' ' +\
7584            'port: ' + repr(self.port) + ' ' +\
7585            'port_override: ' + repr(self.port_override) + ' ' +\
7586            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7587            'tags: ' + repr(self.tags) + ' ' +\
7588            'tls_required: ' + repr(self.tls_required) + ' ' +\
7589            'username: ' + repr(self.username) + ' ' +\
7590            '>'
7591
7592    def to_dict(self):
7593        return {
7594            'auth_database': self.auth_database,
7595            'bind_interface': self.bind_interface,
7596            'egress_filter': self.egress_filter,
7597            'healthy': self.healthy,
7598            'hostname': self.hostname,
7599            'id': self.id,
7600            'name': self.name,
7601            'password': self.password,
7602            'port': self.port,
7603            'port_override': self.port_override,
7604            'secret_store_id': self.secret_store_id,
7605            'tags': self.tags,
7606            'tls_required': self.tls_required,
7607            'username': self.username,
7608        }
7609
7610    @classmethod
7611    def from_dict(cls, d):
7612        return cls(
7613            auth_database=d.get('auth_database'),
7614            bind_interface=d.get('bind_interface'),
7615            egress_filter=d.get('egress_filter'),
7616            healthy=d.get('healthy'),
7617            hostname=d.get('hostname'),
7618            id=d.get('id'),
7619            name=d.get('name'),
7620            password=d.get('password'),
7621            port=d.get('port'),
7622            port_override=d.get('port_override'),
7623            secret_store_id=d.get('secret_store_id'),
7624            tags=d.get('tags'),
7625            tls_required=d.get('tls_required'),
7626            username=d.get('username'),
7627        )

MongoHost is currently unstable, and its API may change, or it may be removed, without a major version bump.

MongoHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7521    def __init__(
7522        self,
7523        auth_database=None,
7524        bind_interface=None,
7525        egress_filter=None,
7526        healthy=None,
7527        hostname=None,
7528        id=None,
7529        name=None,
7530        password=None,
7531        port=None,
7532        port_override=None,
7533        secret_store_id=None,
7534        tags=None,
7535        tls_required=None,
7536        username=None,
7537    ):
7538        self.auth_database = auth_database if auth_database is not None else ''
7539        self.bind_interface = bind_interface if bind_interface is not None else ''
7540        '''
7541         Bind interface
7542        '''
7543        self.egress_filter = egress_filter if egress_filter is not None else ''
7544        '''
7545         A filter applied to the routing logic to pin datasource to nodes.
7546        '''
7547        self.healthy = healthy if healthy is not None else False
7548        '''
7549         True if the datasource is reachable and the credentials are valid.
7550        '''
7551        self.hostname = hostname if hostname is not None else ''
7552        self.id = id if id is not None else ''
7553        '''
7554         Unique identifier of the Resource.
7555        '''
7556        self.name = name if name is not None else ''
7557        '''
7558         Unique human-readable name of the Resource.
7559        '''
7560        self.password = password if password is not None else ''
7561        self.port = port if port is not None else 0
7562        self.port_override = port_override if port_override is not None else 0
7563        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7564        '''
7565         ID of the secret store containing credentials for this resource, if any.
7566        '''
7567        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7568        '''
7569         Tags is a map of key, value pairs.
7570        '''
7571        self.tls_required = tls_required if tls_required is not None else False
7572        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7592    def to_dict(self):
7593        return {
7594            'auth_database': self.auth_database,
7595            'bind_interface': self.bind_interface,
7596            'egress_filter': self.egress_filter,
7597            'healthy': self.healthy,
7598            'hostname': self.hostname,
7599            'id': self.id,
7600            'name': self.name,
7601            'password': self.password,
7602            'port': self.port,
7603            'port_override': self.port_override,
7604            'secret_store_id': self.secret_store_id,
7605            'tags': self.tags,
7606            'tls_required': self.tls_required,
7607            'username': self.username,
7608        }
@classmethod
def from_dict(cls, d)
7610    @classmethod
7611    def from_dict(cls, d):
7612        return cls(
7613            auth_database=d.get('auth_database'),
7614            bind_interface=d.get('bind_interface'),
7615            egress_filter=d.get('egress_filter'),
7616            healthy=d.get('healthy'),
7617            hostname=d.get('hostname'),
7618            id=d.get('id'),
7619            name=d.get('name'),
7620            password=d.get('password'),
7621            port=d.get('port'),
7622            port_override=d.get('port_override'),
7623            secret_store_id=d.get('secret_store_id'),
7624            tags=d.get('tags'),
7625            tls_required=d.get('tls_required'),
7626            username=d.get('username'),
7627        )
class MongoLegacyHost:
7630class MongoLegacyHost:
7631    __slots__ = [
7632        'auth_database',
7633        'bind_interface',
7634        'egress_filter',
7635        'healthy',
7636        'hostname',
7637        'id',
7638        'name',
7639        'password',
7640        'port',
7641        'port_override',
7642        'replica_set',
7643        'secret_store_id',
7644        'tags',
7645        'tls_required',
7646        'username',
7647    ]
7648
7649    def __init__(
7650        self,
7651        auth_database=None,
7652        bind_interface=None,
7653        egress_filter=None,
7654        healthy=None,
7655        hostname=None,
7656        id=None,
7657        name=None,
7658        password=None,
7659        port=None,
7660        port_override=None,
7661        replica_set=None,
7662        secret_store_id=None,
7663        tags=None,
7664        tls_required=None,
7665        username=None,
7666    ):
7667        self.auth_database = auth_database if auth_database is not None else ''
7668        self.bind_interface = bind_interface if bind_interface is not None else ''
7669        '''
7670         Bind interface
7671        '''
7672        self.egress_filter = egress_filter if egress_filter is not None else ''
7673        '''
7674         A filter applied to the routing logic to pin datasource to nodes.
7675        '''
7676        self.healthy = healthy if healthy is not None else False
7677        '''
7678         True if the datasource is reachable and the credentials are valid.
7679        '''
7680        self.hostname = hostname if hostname is not None else ''
7681        self.id = id if id is not None else ''
7682        '''
7683         Unique identifier of the Resource.
7684        '''
7685        self.name = name if name is not None else ''
7686        '''
7687         Unique human-readable name of the Resource.
7688        '''
7689        self.password = password if password is not None else ''
7690        self.port = port if port is not None else 0
7691        self.port_override = port_override if port_override is not None else 0
7692        self.replica_set = replica_set if replica_set is not None else ''
7693        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7694        '''
7695         ID of the secret store containing credentials for this resource, if any.
7696        '''
7697        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7698        '''
7699         Tags is a map of key, value pairs.
7700        '''
7701        self.tls_required = tls_required if tls_required is not None else False
7702        self.username = username if username is not None else ''
7703
7704    def __repr__(self):
7705        return '<sdm.MongoLegacyHost ' + \
7706            'auth_database: ' + repr(self.auth_database) + ' ' +\
7707            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7708            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7709            'healthy: ' + repr(self.healthy) + ' ' +\
7710            'hostname: ' + repr(self.hostname) + ' ' +\
7711            'id: ' + repr(self.id) + ' ' +\
7712            'name: ' + repr(self.name) + ' ' +\
7713            'password: ' + repr(self.password) + ' ' +\
7714            'port: ' + repr(self.port) + ' ' +\
7715            'port_override: ' + repr(self.port_override) + ' ' +\
7716            'replica_set: ' + repr(self.replica_set) + ' ' +\
7717            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7718            'tags: ' + repr(self.tags) + ' ' +\
7719            'tls_required: ' + repr(self.tls_required) + ' ' +\
7720            'username: ' + repr(self.username) + ' ' +\
7721            '>'
7722
7723    def to_dict(self):
7724        return {
7725            'auth_database': self.auth_database,
7726            'bind_interface': self.bind_interface,
7727            'egress_filter': self.egress_filter,
7728            'healthy': self.healthy,
7729            'hostname': self.hostname,
7730            'id': self.id,
7731            'name': self.name,
7732            'password': self.password,
7733            'port': self.port,
7734            'port_override': self.port_override,
7735            'replica_set': self.replica_set,
7736            'secret_store_id': self.secret_store_id,
7737            'tags': self.tags,
7738            'tls_required': self.tls_required,
7739            'username': self.username,
7740        }
7741
7742    @classmethod
7743    def from_dict(cls, d):
7744        return cls(
7745            auth_database=d.get('auth_database'),
7746            bind_interface=d.get('bind_interface'),
7747            egress_filter=d.get('egress_filter'),
7748            healthy=d.get('healthy'),
7749            hostname=d.get('hostname'),
7750            id=d.get('id'),
7751            name=d.get('name'),
7752            password=d.get('password'),
7753            port=d.get('port'),
7754            port_override=d.get('port_override'),
7755            replica_set=d.get('replica_set'),
7756            secret_store_id=d.get('secret_store_id'),
7757            tags=d.get('tags'),
7758            tls_required=d.get('tls_required'),
7759            username=d.get('username'),
7760        )
MongoLegacyHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7649    def __init__(
7650        self,
7651        auth_database=None,
7652        bind_interface=None,
7653        egress_filter=None,
7654        healthy=None,
7655        hostname=None,
7656        id=None,
7657        name=None,
7658        password=None,
7659        port=None,
7660        port_override=None,
7661        replica_set=None,
7662        secret_store_id=None,
7663        tags=None,
7664        tls_required=None,
7665        username=None,
7666    ):
7667        self.auth_database = auth_database if auth_database is not None else ''
7668        self.bind_interface = bind_interface if bind_interface is not None else ''
7669        '''
7670         Bind interface
7671        '''
7672        self.egress_filter = egress_filter if egress_filter is not None else ''
7673        '''
7674         A filter applied to the routing logic to pin datasource to nodes.
7675        '''
7676        self.healthy = healthy if healthy is not None else False
7677        '''
7678         True if the datasource is reachable and the credentials are valid.
7679        '''
7680        self.hostname = hostname if hostname is not None else ''
7681        self.id = id if id is not None else ''
7682        '''
7683         Unique identifier of the Resource.
7684        '''
7685        self.name = name if name is not None else ''
7686        '''
7687         Unique human-readable name of the Resource.
7688        '''
7689        self.password = password if password is not None else ''
7690        self.port = port if port is not None else 0
7691        self.port_override = port_override if port_override is not None else 0
7692        self.replica_set = replica_set if replica_set is not None else ''
7693        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7694        '''
7695         ID of the secret store containing credentials for this resource, if any.
7696        '''
7697        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7698        '''
7699         Tags is a map of key, value pairs.
7700        '''
7701        self.tls_required = tls_required if tls_required is not None else False
7702        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7723    def to_dict(self):
7724        return {
7725            'auth_database': self.auth_database,
7726            'bind_interface': self.bind_interface,
7727            'egress_filter': self.egress_filter,
7728            'healthy': self.healthy,
7729            'hostname': self.hostname,
7730            'id': self.id,
7731            'name': self.name,
7732            'password': self.password,
7733            'port': self.port,
7734            'port_override': self.port_override,
7735            'replica_set': self.replica_set,
7736            'secret_store_id': self.secret_store_id,
7737            'tags': self.tags,
7738            'tls_required': self.tls_required,
7739            'username': self.username,
7740        }
@classmethod
def from_dict(cls, d)
7742    @classmethod
7743    def from_dict(cls, d):
7744        return cls(
7745            auth_database=d.get('auth_database'),
7746            bind_interface=d.get('bind_interface'),
7747            egress_filter=d.get('egress_filter'),
7748            healthy=d.get('healthy'),
7749            hostname=d.get('hostname'),
7750            id=d.get('id'),
7751            name=d.get('name'),
7752            password=d.get('password'),
7753            port=d.get('port'),
7754            port_override=d.get('port_override'),
7755            replica_set=d.get('replica_set'),
7756            secret_store_id=d.get('secret_store_id'),
7757            tags=d.get('tags'),
7758            tls_required=d.get('tls_required'),
7759            username=d.get('username'),
7760        )
class MongoLegacyReplicaset:
7763class MongoLegacyReplicaset:
7764    __slots__ = [
7765        'auth_database',
7766        'bind_interface',
7767        'connect_to_replica',
7768        'egress_filter',
7769        'healthy',
7770        'hostname',
7771        'id',
7772        'name',
7773        'password',
7774        'port',
7775        'port_override',
7776        'replica_set',
7777        'secret_store_id',
7778        'tags',
7779        'tls_required',
7780        'username',
7781    ]
7782
7783    def __init__(
7784        self,
7785        auth_database=None,
7786        bind_interface=None,
7787        connect_to_replica=None,
7788        egress_filter=None,
7789        healthy=None,
7790        hostname=None,
7791        id=None,
7792        name=None,
7793        password=None,
7794        port=None,
7795        port_override=None,
7796        replica_set=None,
7797        secret_store_id=None,
7798        tags=None,
7799        tls_required=None,
7800        username=None,
7801    ):
7802        self.auth_database = auth_database if auth_database is not None else ''
7803        self.bind_interface = bind_interface if bind_interface is not None else ''
7804        '''
7805         Bind interface
7806        '''
7807        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7808        self.egress_filter = egress_filter if egress_filter is not None else ''
7809        '''
7810         A filter applied to the routing logic to pin datasource to nodes.
7811        '''
7812        self.healthy = healthy if healthy is not None else False
7813        '''
7814         True if the datasource is reachable and the credentials are valid.
7815        '''
7816        self.hostname = hostname if hostname is not None else ''
7817        self.id = id if id is not None else ''
7818        '''
7819         Unique identifier of the Resource.
7820        '''
7821        self.name = name if name is not None else ''
7822        '''
7823         Unique human-readable name of the Resource.
7824        '''
7825        self.password = password if password is not None else ''
7826        self.port = port if port is not None else 0
7827        self.port_override = port_override if port_override is not None else 0
7828        self.replica_set = replica_set if replica_set is not None else ''
7829        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7830        '''
7831         ID of the secret store containing credentials for this resource, if any.
7832        '''
7833        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7834        '''
7835         Tags is a map of key, value pairs.
7836        '''
7837        self.tls_required = tls_required if tls_required is not None else False
7838        self.username = username if username is not None else ''
7839
7840    def __repr__(self):
7841        return '<sdm.MongoLegacyReplicaset ' + \
7842            'auth_database: ' + repr(self.auth_database) + ' ' +\
7843            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7844            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
7845            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7846            'healthy: ' + repr(self.healthy) + ' ' +\
7847            'hostname: ' + repr(self.hostname) + ' ' +\
7848            'id: ' + repr(self.id) + ' ' +\
7849            'name: ' + repr(self.name) + ' ' +\
7850            'password: ' + repr(self.password) + ' ' +\
7851            'port: ' + repr(self.port) + ' ' +\
7852            'port_override: ' + repr(self.port_override) + ' ' +\
7853            'replica_set: ' + repr(self.replica_set) + ' ' +\
7854            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7855            'tags: ' + repr(self.tags) + ' ' +\
7856            'tls_required: ' + repr(self.tls_required) + ' ' +\
7857            'username: ' + repr(self.username) + ' ' +\
7858            '>'
7859
7860    def to_dict(self):
7861        return {
7862            'auth_database': self.auth_database,
7863            'bind_interface': self.bind_interface,
7864            'connect_to_replica': self.connect_to_replica,
7865            'egress_filter': self.egress_filter,
7866            'healthy': self.healthy,
7867            'hostname': self.hostname,
7868            'id': self.id,
7869            'name': self.name,
7870            'password': self.password,
7871            'port': self.port,
7872            'port_override': self.port_override,
7873            'replica_set': self.replica_set,
7874            'secret_store_id': self.secret_store_id,
7875            'tags': self.tags,
7876            'tls_required': self.tls_required,
7877            'username': self.username,
7878        }
7879
7880    @classmethod
7881    def from_dict(cls, d):
7882        return cls(
7883            auth_database=d.get('auth_database'),
7884            bind_interface=d.get('bind_interface'),
7885            connect_to_replica=d.get('connect_to_replica'),
7886            egress_filter=d.get('egress_filter'),
7887            healthy=d.get('healthy'),
7888            hostname=d.get('hostname'),
7889            id=d.get('id'),
7890            name=d.get('name'),
7891            password=d.get('password'),
7892            port=d.get('port'),
7893            port_override=d.get('port_override'),
7894            replica_set=d.get('replica_set'),
7895            secret_store_id=d.get('secret_store_id'),
7896            tags=d.get('tags'),
7897            tls_required=d.get('tls_required'),
7898            username=d.get('username'),
7899        )
MongoLegacyReplicaset( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7783    def __init__(
7784        self,
7785        auth_database=None,
7786        bind_interface=None,
7787        connect_to_replica=None,
7788        egress_filter=None,
7789        healthy=None,
7790        hostname=None,
7791        id=None,
7792        name=None,
7793        password=None,
7794        port=None,
7795        port_override=None,
7796        replica_set=None,
7797        secret_store_id=None,
7798        tags=None,
7799        tls_required=None,
7800        username=None,
7801    ):
7802        self.auth_database = auth_database if auth_database is not None else ''
7803        self.bind_interface = bind_interface if bind_interface is not None else ''
7804        '''
7805         Bind interface
7806        '''
7807        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7808        self.egress_filter = egress_filter if egress_filter is not None else ''
7809        '''
7810         A filter applied to the routing logic to pin datasource to nodes.
7811        '''
7812        self.healthy = healthy if healthy is not None else False
7813        '''
7814         True if the datasource is reachable and the credentials are valid.
7815        '''
7816        self.hostname = hostname if hostname is not None else ''
7817        self.id = id if id is not None else ''
7818        '''
7819         Unique identifier of the Resource.
7820        '''
7821        self.name = name if name is not None else ''
7822        '''
7823         Unique human-readable name of the Resource.
7824        '''
7825        self.password = password if password is not None else ''
7826        self.port = port if port is not None else 0
7827        self.port_override = port_override if port_override is not None else 0
7828        self.replica_set = replica_set if replica_set is not None else ''
7829        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7830        '''
7831         ID of the secret store containing credentials for this resource, if any.
7832        '''
7833        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7834        '''
7835         Tags is a map of key, value pairs.
7836        '''
7837        self.tls_required = tls_required if tls_required is not None else False
7838        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7860    def to_dict(self):
7861        return {
7862            'auth_database': self.auth_database,
7863            'bind_interface': self.bind_interface,
7864            'connect_to_replica': self.connect_to_replica,
7865            'egress_filter': self.egress_filter,
7866            'healthy': self.healthy,
7867            'hostname': self.hostname,
7868            'id': self.id,
7869            'name': self.name,
7870            'password': self.password,
7871            'port': self.port,
7872            'port_override': self.port_override,
7873            'replica_set': self.replica_set,
7874            'secret_store_id': self.secret_store_id,
7875            'tags': self.tags,
7876            'tls_required': self.tls_required,
7877            'username': self.username,
7878        }
@classmethod
def from_dict(cls, d)
7880    @classmethod
7881    def from_dict(cls, d):
7882        return cls(
7883            auth_database=d.get('auth_database'),
7884            bind_interface=d.get('bind_interface'),
7885            connect_to_replica=d.get('connect_to_replica'),
7886            egress_filter=d.get('egress_filter'),
7887            healthy=d.get('healthy'),
7888            hostname=d.get('hostname'),
7889            id=d.get('id'),
7890            name=d.get('name'),
7891            password=d.get('password'),
7892            port=d.get('port'),
7893            port_override=d.get('port_override'),
7894            replica_set=d.get('replica_set'),
7895            secret_store_id=d.get('secret_store_id'),
7896            tags=d.get('tags'),
7897            tls_required=d.get('tls_required'),
7898            username=d.get('username'),
7899        )
class MongoReplicaSet:
7902class MongoReplicaSet:
7903    '''
7904    MongoReplicaSet is currently unstable, and its API may change, or it may be removed,
7905    without a major version bump.
7906    '''
7907    __slots__ = [
7908        'auth_database',
7909        'bind_interface',
7910        'connect_to_replica',
7911        'egress_filter',
7912        'healthy',
7913        'hostname',
7914        'id',
7915        'name',
7916        'password',
7917        'port',
7918        'port_override',
7919        'replica_set',
7920        'secret_store_id',
7921        'tags',
7922        'tls_required',
7923        'username',
7924    ]
7925
7926    def __init__(
7927        self,
7928        auth_database=None,
7929        bind_interface=None,
7930        connect_to_replica=None,
7931        egress_filter=None,
7932        healthy=None,
7933        hostname=None,
7934        id=None,
7935        name=None,
7936        password=None,
7937        port=None,
7938        port_override=None,
7939        replica_set=None,
7940        secret_store_id=None,
7941        tags=None,
7942        tls_required=None,
7943        username=None,
7944    ):
7945        self.auth_database = auth_database if auth_database is not None else ''
7946        self.bind_interface = bind_interface if bind_interface is not None else ''
7947        '''
7948         Bind interface
7949        '''
7950        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7951        self.egress_filter = egress_filter if egress_filter is not None else ''
7952        '''
7953         A filter applied to the routing logic to pin datasource to nodes.
7954        '''
7955        self.healthy = healthy if healthy is not None else False
7956        '''
7957         True if the datasource is reachable and the credentials are valid.
7958        '''
7959        self.hostname = hostname if hostname is not None else ''
7960        self.id = id if id is not None else ''
7961        '''
7962         Unique identifier of the Resource.
7963        '''
7964        self.name = name if name is not None else ''
7965        '''
7966         Unique human-readable name of the Resource.
7967        '''
7968        self.password = password if password is not None else ''
7969        self.port = port if port is not None else 0
7970        self.port_override = port_override if port_override is not None else 0
7971        self.replica_set = replica_set if replica_set is not None else ''
7972        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7973        '''
7974         ID of the secret store containing credentials for this resource, if any.
7975        '''
7976        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7977        '''
7978         Tags is a map of key, value pairs.
7979        '''
7980        self.tls_required = tls_required if tls_required is not None else False
7981        self.username = username if username is not None else ''
7982
7983    def __repr__(self):
7984        return '<sdm.MongoReplicaSet ' + \
7985            'auth_database: ' + repr(self.auth_database) + ' ' +\
7986            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7987            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
7988            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7989            'healthy: ' + repr(self.healthy) + ' ' +\
7990            'hostname: ' + repr(self.hostname) + ' ' +\
7991            'id: ' + repr(self.id) + ' ' +\
7992            'name: ' + repr(self.name) + ' ' +\
7993            'password: ' + repr(self.password) + ' ' +\
7994            'port: ' + repr(self.port) + ' ' +\
7995            'port_override: ' + repr(self.port_override) + ' ' +\
7996            'replica_set: ' + repr(self.replica_set) + ' ' +\
7997            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7998            'tags: ' + repr(self.tags) + ' ' +\
7999            'tls_required: ' + repr(self.tls_required) + ' ' +\
8000            'username: ' + repr(self.username) + ' ' +\
8001            '>'
8002
8003    def to_dict(self):
8004        return {
8005            'auth_database': self.auth_database,
8006            'bind_interface': self.bind_interface,
8007            'connect_to_replica': self.connect_to_replica,
8008            'egress_filter': self.egress_filter,
8009            'healthy': self.healthy,
8010            'hostname': self.hostname,
8011            'id': self.id,
8012            'name': self.name,
8013            'password': self.password,
8014            'port': self.port,
8015            'port_override': self.port_override,
8016            'replica_set': self.replica_set,
8017            'secret_store_id': self.secret_store_id,
8018            'tags': self.tags,
8019            'tls_required': self.tls_required,
8020            'username': self.username,
8021        }
8022
8023    @classmethod
8024    def from_dict(cls, d):
8025        return cls(
8026            auth_database=d.get('auth_database'),
8027            bind_interface=d.get('bind_interface'),
8028            connect_to_replica=d.get('connect_to_replica'),
8029            egress_filter=d.get('egress_filter'),
8030            healthy=d.get('healthy'),
8031            hostname=d.get('hostname'),
8032            id=d.get('id'),
8033            name=d.get('name'),
8034            password=d.get('password'),
8035            port=d.get('port'),
8036            port_override=d.get('port_override'),
8037            replica_set=d.get('replica_set'),
8038            secret_store_id=d.get('secret_store_id'),
8039            tags=d.get('tags'),
8040            tls_required=d.get('tls_required'),
8041            username=d.get('username'),
8042        )

MongoReplicaSet is currently unstable, and its API may change, or it may be removed, without a major version bump.

MongoReplicaSet( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7926    def __init__(
7927        self,
7928        auth_database=None,
7929        bind_interface=None,
7930        connect_to_replica=None,
7931        egress_filter=None,
7932        healthy=None,
7933        hostname=None,
7934        id=None,
7935        name=None,
7936        password=None,
7937        port=None,
7938        port_override=None,
7939        replica_set=None,
7940        secret_store_id=None,
7941        tags=None,
7942        tls_required=None,
7943        username=None,
7944    ):
7945        self.auth_database = auth_database if auth_database is not None else ''
7946        self.bind_interface = bind_interface if bind_interface is not None else ''
7947        '''
7948         Bind interface
7949        '''
7950        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7951        self.egress_filter = egress_filter if egress_filter is not None else ''
7952        '''
7953         A filter applied to the routing logic to pin datasource to nodes.
7954        '''
7955        self.healthy = healthy if healthy is not None else False
7956        '''
7957         True if the datasource is reachable and the credentials are valid.
7958        '''
7959        self.hostname = hostname if hostname is not None else ''
7960        self.id = id if id is not None else ''
7961        '''
7962         Unique identifier of the Resource.
7963        '''
7964        self.name = name if name is not None else ''
7965        '''
7966         Unique human-readable name of the Resource.
7967        '''
7968        self.password = password if password is not None else ''
7969        self.port = port if port is not None else 0
7970        self.port_override = port_override if port_override is not None else 0
7971        self.replica_set = replica_set if replica_set is not None else ''
7972        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7973        '''
7974         ID of the secret store containing credentials for this resource, if any.
7975        '''
7976        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7977        '''
7978         Tags is a map of key, value pairs.
7979        '''
7980        self.tls_required = tls_required if tls_required is not None else False
7981        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8003    def to_dict(self):
8004        return {
8005            'auth_database': self.auth_database,
8006            'bind_interface': self.bind_interface,
8007            'connect_to_replica': self.connect_to_replica,
8008            'egress_filter': self.egress_filter,
8009            'healthy': self.healthy,
8010            'hostname': self.hostname,
8011            'id': self.id,
8012            'name': self.name,
8013            'password': self.password,
8014            'port': self.port,
8015            'port_override': self.port_override,
8016            'replica_set': self.replica_set,
8017            'secret_store_id': self.secret_store_id,
8018            'tags': self.tags,
8019            'tls_required': self.tls_required,
8020            'username': self.username,
8021        }
@classmethod
def from_dict(cls, d)
8023    @classmethod
8024    def from_dict(cls, d):
8025        return cls(
8026            auth_database=d.get('auth_database'),
8027            bind_interface=d.get('bind_interface'),
8028            connect_to_replica=d.get('connect_to_replica'),
8029            egress_filter=d.get('egress_filter'),
8030            healthy=d.get('healthy'),
8031            hostname=d.get('hostname'),
8032            id=d.get('id'),
8033            name=d.get('name'),
8034            password=d.get('password'),
8035            port=d.get('port'),
8036            port_override=d.get('port_override'),
8037            replica_set=d.get('replica_set'),
8038            secret_store_id=d.get('secret_store_id'),
8039            tags=d.get('tags'),
8040            tls_required=d.get('tls_required'),
8041            username=d.get('username'),
8042        )
class MongoShardedCluster:
8045class MongoShardedCluster:
8046    '''
8047    MongoShardedCluster is currently unstable, and its API may change, or it may be removed,
8048    without a major version bump.
8049    '''
8050    __slots__ = [
8051        'auth_database',
8052        'bind_interface',
8053        'egress_filter',
8054        'healthy',
8055        'hostname',
8056        'id',
8057        'name',
8058        'password',
8059        'port_override',
8060        'secret_store_id',
8061        'tags',
8062        'tls_required',
8063        'username',
8064    ]
8065
8066    def __init__(
8067        self,
8068        auth_database=None,
8069        bind_interface=None,
8070        egress_filter=None,
8071        healthy=None,
8072        hostname=None,
8073        id=None,
8074        name=None,
8075        password=None,
8076        port_override=None,
8077        secret_store_id=None,
8078        tags=None,
8079        tls_required=None,
8080        username=None,
8081    ):
8082        self.auth_database = auth_database if auth_database is not None else ''
8083        self.bind_interface = bind_interface if bind_interface is not None else ''
8084        '''
8085         Bind interface
8086        '''
8087        self.egress_filter = egress_filter if egress_filter is not None else ''
8088        '''
8089         A filter applied to the routing logic to pin datasource to nodes.
8090        '''
8091        self.healthy = healthy if healthy is not None else False
8092        '''
8093         True if the datasource is reachable and the credentials are valid.
8094        '''
8095        self.hostname = hostname if hostname is not None else ''
8096        self.id = id if id is not None else ''
8097        '''
8098         Unique identifier of the Resource.
8099        '''
8100        self.name = name if name is not None else ''
8101        '''
8102         Unique human-readable name of the Resource.
8103        '''
8104        self.password = password if password is not None else ''
8105        self.port_override = port_override if port_override is not None else 0
8106        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8107        '''
8108         ID of the secret store containing credentials for this resource, if any.
8109        '''
8110        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8111        '''
8112         Tags is a map of key, value pairs.
8113        '''
8114        self.tls_required = tls_required if tls_required is not None else False
8115        self.username = username if username is not None else ''
8116
8117    def __repr__(self):
8118        return '<sdm.MongoShardedCluster ' + \
8119            'auth_database: ' + repr(self.auth_database) + ' ' +\
8120            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8121            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8122            'healthy: ' + repr(self.healthy) + ' ' +\
8123            'hostname: ' + repr(self.hostname) + ' ' +\
8124            'id: ' + repr(self.id) + ' ' +\
8125            'name: ' + repr(self.name) + ' ' +\
8126            'password: ' + repr(self.password) + ' ' +\
8127            'port_override: ' + repr(self.port_override) + ' ' +\
8128            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8129            'tags: ' + repr(self.tags) + ' ' +\
8130            'tls_required: ' + repr(self.tls_required) + ' ' +\
8131            'username: ' + repr(self.username) + ' ' +\
8132            '>'
8133
8134    def to_dict(self):
8135        return {
8136            'auth_database': self.auth_database,
8137            'bind_interface': self.bind_interface,
8138            'egress_filter': self.egress_filter,
8139            'healthy': self.healthy,
8140            'hostname': self.hostname,
8141            'id': self.id,
8142            'name': self.name,
8143            'password': self.password,
8144            'port_override': self.port_override,
8145            'secret_store_id': self.secret_store_id,
8146            'tags': self.tags,
8147            'tls_required': self.tls_required,
8148            'username': self.username,
8149        }
8150
8151    @classmethod
8152    def from_dict(cls, d):
8153        return cls(
8154            auth_database=d.get('auth_database'),
8155            bind_interface=d.get('bind_interface'),
8156            egress_filter=d.get('egress_filter'),
8157            healthy=d.get('healthy'),
8158            hostname=d.get('hostname'),
8159            id=d.get('id'),
8160            name=d.get('name'),
8161            password=d.get('password'),
8162            port_override=d.get('port_override'),
8163            secret_store_id=d.get('secret_store_id'),
8164            tags=d.get('tags'),
8165            tls_required=d.get('tls_required'),
8166            username=d.get('username'),
8167        )

MongoShardedCluster is currently unstable, and its API may change, or it may be removed, without a major version bump.

MongoShardedCluster( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8066    def __init__(
8067        self,
8068        auth_database=None,
8069        bind_interface=None,
8070        egress_filter=None,
8071        healthy=None,
8072        hostname=None,
8073        id=None,
8074        name=None,
8075        password=None,
8076        port_override=None,
8077        secret_store_id=None,
8078        tags=None,
8079        tls_required=None,
8080        username=None,
8081    ):
8082        self.auth_database = auth_database if auth_database is not None else ''
8083        self.bind_interface = bind_interface if bind_interface is not None else ''
8084        '''
8085         Bind interface
8086        '''
8087        self.egress_filter = egress_filter if egress_filter is not None else ''
8088        '''
8089         A filter applied to the routing logic to pin datasource to nodes.
8090        '''
8091        self.healthy = healthy if healthy is not None else False
8092        '''
8093         True if the datasource is reachable and the credentials are valid.
8094        '''
8095        self.hostname = hostname if hostname is not None else ''
8096        self.id = id if id is not None else ''
8097        '''
8098         Unique identifier of the Resource.
8099        '''
8100        self.name = name if name is not None else ''
8101        '''
8102         Unique human-readable name of the Resource.
8103        '''
8104        self.password = password if password is not None else ''
8105        self.port_override = port_override if port_override is not None else 0
8106        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8107        '''
8108         ID of the secret store containing credentials for this resource, if any.
8109        '''
8110        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8111        '''
8112         Tags is a map of key, value pairs.
8113        '''
8114        self.tls_required = tls_required if tls_required is not None else False
8115        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8134    def to_dict(self):
8135        return {
8136            'auth_database': self.auth_database,
8137            'bind_interface': self.bind_interface,
8138            'egress_filter': self.egress_filter,
8139            'healthy': self.healthy,
8140            'hostname': self.hostname,
8141            'id': self.id,
8142            'name': self.name,
8143            'password': self.password,
8144            'port_override': self.port_override,
8145            'secret_store_id': self.secret_store_id,
8146            'tags': self.tags,
8147            'tls_required': self.tls_required,
8148            'username': self.username,
8149        }
@classmethod
def from_dict(cls, d)
8151    @classmethod
8152    def from_dict(cls, d):
8153        return cls(
8154            auth_database=d.get('auth_database'),
8155            bind_interface=d.get('bind_interface'),
8156            egress_filter=d.get('egress_filter'),
8157            healthy=d.get('healthy'),
8158            hostname=d.get('hostname'),
8159            id=d.get('id'),
8160            name=d.get('name'),
8161            password=d.get('password'),
8162            port_override=d.get('port_override'),
8163            secret_store_id=d.get('secret_store_id'),
8164            tags=d.get('tags'),
8165            tls_required=d.get('tls_required'),
8166            username=d.get('username'),
8167        )
class Mysql:
8170class Mysql:
8171    __slots__ = [
8172        'bind_interface',
8173        'database',
8174        'egress_filter',
8175        'healthy',
8176        'hostname',
8177        'id',
8178        'name',
8179        'password',
8180        'port',
8181        'port_override',
8182        'secret_store_id',
8183        'tags',
8184        'username',
8185    ]
8186
8187    def __init__(
8188        self,
8189        bind_interface=None,
8190        database=None,
8191        egress_filter=None,
8192        healthy=None,
8193        hostname=None,
8194        id=None,
8195        name=None,
8196        password=None,
8197        port=None,
8198        port_override=None,
8199        secret_store_id=None,
8200        tags=None,
8201        username=None,
8202    ):
8203        self.bind_interface = bind_interface if bind_interface is not None else ''
8204        '''
8205         Bind interface
8206        '''
8207        self.database = database if database is not None else ''
8208        self.egress_filter = egress_filter if egress_filter is not None else ''
8209        '''
8210         A filter applied to the routing logic to pin datasource to nodes.
8211        '''
8212        self.healthy = healthy if healthy is not None else False
8213        '''
8214         True if the datasource is reachable and the credentials are valid.
8215        '''
8216        self.hostname = hostname if hostname is not None else ''
8217        self.id = id if id is not None else ''
8218        '''
8219         Unique identifier of the Resource.
8220        '''
8221        self.name = name if name is not None else ''
8222        '''
8223         Unique human-readable name of the Resource.
8224        '''
8225        self.password = password if password is not None else ''
8226        self.port = port if port is not None else 0
8227        self.port_override = port_override if port_override is not None else 0
8228        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8229        '''
8230         ID of the secret store containing credentials for this resource, if any.
8231        '''
8232        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8233        '''
8234         Tags is a map of key, value pairs.
8235        '''
8236        self.username = username if username is not None else ''
8237
8238    def __repr__(self):
8239        return '<sdm.Mysql ' + \
8240            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8241            'database: ' + repr(self.database) + ' ' +\
8242            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8243            'healthy: ' + repr(self.healthy) + ' ' +\
8244            'hostname: ' + repr(self.hostname) + ' ' +\
8245            'id: ' + repr(self.id) + ' ' +\
8246            'name: ' + repr(self.name) + ' ' +\
8247            'password: ' + repr(self.password) + ' ' +\
8248            'port: ' + repr(self.port) + ' ' +\
8249            'port_override: ' + repr(self.port_override) + ' ' +\
8250            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8251            'tags: ' + repr(self.tags) + ' ' +\
8252            'username: ' + repr(self.username) + ' ' +\
8253            '>'
8254
8255    def to_dict(self):
8256        return {
8257            'bind_interface': self.bind_interface,
8258            'database': self.database,
8259            'egress_filter': self.egress_filter,
8260            'healthy': self.healthy,
8261            'hostname': self.hostname,
8262            'id': self.id,
8263            'name': self.name,
8264            'password': self.password,
8265            'port': self.port,
8266            'port_override': self.port_override,
8267            'secret_store_id': self.secret_store_id,
8268            'tags': self.tags,
8269            'username': self.username,
8270        }
8271
8272    @classmethod
8273    def from_dict(cls, d):
8274        return cls(
8275            bind_interface=d.get('bind_interface'),
8276            database=d.get('database'),
8277            egress_filter=d.get('egress_filter'),
8278            healthy=d.get('healthy'),
8279            hostname=d.get('hostname'),
8280            id=d.get('id'),
8281            name=d.get('name'),
8282            password=d.get('password'),
8283            port=d.get('port'),
8284            port_override=d.get('port_override'),
8285            secret_store_id=d.get('secret_store_id'),
8286            tags=d.get('tags'),
8287            username=d.get('username'),
8288        )
Mysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
8187    def __init__(
8188        self,
8189        bind_interface=None,
8190        database=None,
8191        egress_filter=None,
8192        healthy=None,
8193        hostname=None,
8194        id=None,
8195        name=None,
8196        password=None,
8197        port=None,
8198        port_override=None,
8199        secret_store_id=None,
8200        tags=None,
8201        username=None,
8202    ):
8203        self.bind_interface = bind_interface if bind_interface is not None else ''
8204        '''
8205         Bind interface
8206        '''
8207        self.database = database if database is not None else ''
8208        self.egress_filter = egress_filter if egress_filter is not None else ''
8209        '''
8210         A filter applied to the routing logic to pin datasource to nodes.
8211        '''
8212        self.healthy = healthy if healthy is not None else False
8213        '''
8214         True if the datasource is reachable and the credentials are valid.
8215        '''
8216        self.hostname = hostname if hostname is not None else ''
8217        self.id = id if id is not None else ''
8218        '''
8219         Unique identifier of the Resource.
8220        '''
8221        self.name = name if name is not None else ''
8222        '''
8223         Unique human-readable name of the Resource.
8224        '''
8225        self.password = password if password is not None else ''
8226        self.port = port if port is not None else 0
8227        self.port_override = port_override if port_override is not None else 0
8228        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8229        '''
8230         ID of the secret store containing credentials for this resource, if any.
8231        '''
8232        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8233        '''
8234         Tags is a map of key, value pairs.
8235        '''
8236        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
8255    def to_dict(self):
8256        return {
8257            'bind_interface': self.bind_interface,
8258            'database': self.database,
8259            'egress_filter': self.egress_filter,
8260            'healthy': self.healthy,
8261            'hostname': self.hostname,
8262            'id': self.id,
8263            'name': self.name,
8264            'password': self.password,
8265            'port': self.port,
8266            'port_override': self.port_override,
8267            'secret_store_id': self.secret_store_id,
8268            'tags': self.tags,
8269            'username': self.username,
8270        }
@classmethod
def from_dict(cls, d)
8272    @classmethod
8273    def from_dict(cls, d):
8274        return cls(
8275            bind_interface=d.get('bind_interface'),
8276            database=d.get('database'),
8277            egress_filter=d.get('egress_filter'),
8278            healthy=d.get('healthy'),
8279            hostname=d.get('hostname'),
8280            id=d.get('id'),
8281            name=d.get('name'),
8282            password=d.get('password'),
8283            port=d.get('port'),
8284            port_override=d.get('port_override'),
8285            secret_store_id=d.get('secret_store_id'),
8286            tags=d.get('tags'),
8287            username=d.get('username'),
8288        )
class Neptune:
8291class Neptune:
8292    __slots__ = [
8293        'bind_interface',
8294        'egress_filter',
8295        'endpoint',
8296        'healthy',
8297        'id',
8298        'name',
8299        'port',
8300        'port_override',
8301        'secret_store_id',
8302        'tags',
8303    ]
8304
8305    def __init__(
8306        self,
8307        bind_interface=None,
8308        egress_filter=None,
8309        endpoint=None,
8310        healthy=None,
8311        id=None,
8312        name=None,
8313        port=None,
8314        port_override=None,
8315        secret_store_id=None,
8316        tags=None,
8317    ):
8318        self.bind_interface = bind_interface if bind_interface is not None else ''
8319        '''
8320         Bind interface
8321        '''
8322        self.egress_filter = egress_filter if egress_filter is not None else ''
8323        '''
8324         A filter applied to the routing logic to pin datasource to nodes.
8325        '''
8326        self.endpoint = endpoint if endpoint is not None else ''
8327        self.healthy = healthy if healthy is not None else False
8328        '''
8329         True if the datasource is reachable and the credentials are valid.
8330        '''
8331        self.id = id if id is not None else ''
8332        '''
8333         Unique identifier of the Resource.
8334        '''
8335        self.name = name if name is not None else ''
8336        '''
8337         Unique human-readable name of the Resource.
8338        '''
8339        self.port = port if port is not None else 0
8340        self.port_override = port_override if port_override is not None else 0
8341        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8342        '''
8343         ID of the secret store containing credentials for this resource, if any.
8344        '''
8345        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8346        '''
8347         Tags is a map of key, value pairs.
8348        '''
8349
8350    def __repr__(self):
8351        return '<sdm.Neptune ' + \
8352            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8353            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8354            'endpoint: ' + repr(self.endpoint) + ' ' +\
8355            'healthy: ' + repr(self.healthy) + ' ' +\
8356            'id: ' + repr(self.id) + ' ' +\
8357            'name: ' + repr(self.name) + ' ' +\
8358            'port: ' + repr(self.port) + ' ' +\
8359            'port_override: ' + repr(self.port_override) + ' ' +\
8360            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8361            'tags: ' + repr(self.tags) + ' ' +\
8362            '>'
8363
8364    def to_dict(self):
8365        return {
8366            'bind_interface': self.bind_interface,
8367            'egress_filter': self.egress_filter,
8368            'endpoint': self.endpoint,
8369            'healthy': self.healthy,
8370            'id': self.id,
8371            'name': self.name,
8372            'port': self.port,
8373            'port_override': self.port_override,
8374            'secret_store_id': self.secret_store_id,
8375            'tags': self.tags,
8376        }
8377
8378    @classmethod
8379    def from_dict(cls, d):
8380        return cls(
8381            bind_interface=d.get('bind_interface'),
8382            egress_filter=d.get('egress_filter'),
8383            endpoint=d.get('endpoint'),
8384            healthy=d.get('healthy'),
8385            id=d.get('id'),
8386            name=d.get('name'),
8387            port=d.get('port'),
8388            port_override=d.get('port_override'),
8389            secret_store_id=d.get('secret_store_id'),
8390            tags=d.get('tags'),
8391        )
Neptune( bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
8305    def __init__(
8306        self,
8307        bind_interface=None,
8308        egress_filter=None,
8309        endpoint=None,
8310        healthy=None,
8311        id=None,
8312        name=None,
8313        port=None,
8314        port_override=None,
8315        secret_store_id=None,
8316        tags=None,
8317    ):
8318        self.bind_interface = bind_interface if bind_interface is not None else ''
8319        '''
8320         Bind interface
8321        '''
8322        self.egress_filter = egress_filter if egress_filter is not None else ''
8323        '''
8324         A filter applied to the routing logic to pin datasource to nodes.
8325        '''
8326        self.endpoint = endpoint if endpoint is not None else ''
8327        self.healthy = healthy if healthy is not None else False
8328        '''
8329         True if the datasource is reachable and the credentials are valid.
8330        '''
8331        self.id = id if id is not None else ''
8332        '''
8333         Unique identifier of the Resource.
8334        '''
8335        self.name = name if name is not None else ''
8336        '''
8337         Unique human-readable name of the Resource.
8338        '''
8339        self.port = port if port is not None else 0
8340        self.port_override = port_override if port_override is not None else 0
8341        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8342        '''
8343         ID of the secret store containing credentials for this resource, if any.
8344        '''
8345        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8346        '''
8347         Tags is a map of key, value pairs.
8348        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
8364    def to_dict(self):
8365        return {
8366            'bind_interface': self.bind_interface,
8367            'egress_filter': self.egress_filter,
8368            'endpoint': self.endpoint,
8369            'healthy': self.healthy,
8370            'id': self.id,
8371            'name': self.name,
8372            'port': self.port,
8373            'port_override': self.port_override,
8374            'secret_store_id': self.secret_store_id,
8375            'tags': self.tags,
8376        }
@classmethod
def from_dict(cls, d)
8378    @classmethod
8379    def from_dict(cls, d):
8380        return cls(
8381            bind_interface=d.get('bind_interface'),
8382            egress_filter=d.get('egress_filter'),
8383            endpoint=d.get('endpoint'),
8384            healthy=d.get('healthy'),
8385            id=d.get('id'),
8386            name=d.get('name'),
8387            port=d.get('port'),
8388            port_override=d.get('port_override'),
8389            secret_store_id=d.get('secret_store_id'),
8390            tags=d.get('tags'),
8391        )
class NeptuneIAM:
8394class NeptuneIAM:
8395    __slots__ = [
8396        'access_key',
8397        'bind_interface',
8398        'egress_filter',
8399        'endpoint',
8400        'healthy',
8401        'id',
8402        'name',
8403        'port',
8404        'port_override',
8405        'region',
8406        'role_arn',
8407        'role_external_id',
8408        'secret_access_key',
8409        'secret_store_id',
8410        'tags',
8411    ]
8412
8413    def __init__(
8414        self,
8415        access_key=None,
8416        bind_interface=None,
8417        egress_filter=None,
8418        endpoint=None,
8419        healthy=None,
8420        id=None,
8421        name=None,
8422        port=None,
8423        port_override=None,
8424        region=None,
8425        role_arn=None,
8426        role_external_id=None,
8427        secret_access_key=None,
8428        secret_store_id=None,
8429        tags=None,
8430    ):
8431        self.access_key = access_key if access_key is not None else ''
8432        self.bind_interface = bind_interface if bind_interface is not None else ''
8433        '''
8434         Bind interface
8435        '''
8436        self.egress_filter = egress_filter if egress_filter is not None else ''
8437        '''
8438         A filter applied to the routing logic to pin datasource to nodes.
8439        '''
8440        self.endpoint = endpoint if endpoint is not None else ''
8441        self.healthy = healthy if healthy is not None else False
8442        '''
8443         True if the datasource is reachable and the credentials are valid.
8444        '''
8445        self.id = id if id is not None else ''
8446        '''
8447         Unique identifier of the Resource.
8448        '''
8449        self.name = name if name is not None else ''
8450        '''
8451         Unique human-readable name of the Resource.
8452        '''
8453        self.port = port if port is not None else 0
8454        self.port_override = port_override if port_override is not None else 0
8455        self.region = region if region is not None else ''
8456        self.role_arn = role_arn if role_arn is not None else ''
8457        self.role_external_id = role_external_id if role_external_id is not None else ''
8458        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
8459        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8460        '''
8461         ID of the secret store containing credentials for this resource, if any.
8462        '''
8463        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8464        '''
8465         Tags is a map of key, value pairs.
8466        '''
8467
8468    def __repr__(self):
8469        return '<sdm.NeptuneIAM ' + \
8470            'access_key: ' + repr(self.access_key) + ' ' +\
8471            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8472            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8473            'endpoint: ' + repr(self.endpoint) + ' ' +\
8474            'healthy: ' + repr(self.healthy) + ' ' +\
8475            'id: ' + repr(self.id) + ' ' +\
8476            'name: ' + repr(self.name) + ' ' +\
8477            'port: ' + repr(self.port) + ' ' +\
8478            'port_override: ' + repr(self.port_override) + ' ' +\
8479            'region: ' + repr(self.region) + ' ' +\
8480            'role_arn: ' + repr(self.role_arn) + ' ' +\
8481            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
8482            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
8483            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8484            'tags: ' + repr(self.tags) + ' ' +\
8485            '>'
8486
8487    def to_dict(self):
8488        return {
8489            'access_key': self.access_key,
8490            'bind_interface': self.bind_interface,
8491            'egress_filter': self.egress_filter,
8492            'endpoint': self.endpoint,
8493            'healthy': self.healthy,
8494            'id': self.id,
8495            'name': self.name,
8496            'port': self.port,
8497            'port_override': self.port_override,
8498            'region': self.region,
8499            'role_arn': self.role_arn,
8500            'role_external_id': self.role_external_id,
8501            'secret_access_key': self.secret_access_key,
8502            'secret_store_id': self.secret_store_id,
8503            'tags': self.tags,
8504        }
8505
8506    @classmethod
8507    def from_dict(cls, d):
8508        return cls(
8509            access_key=d.get('access_key'),
8510            bind_interface=d.get('bind_interface'),
8511            egress_filter=d.get('egress_filter'),
8512            endpoint=d.get('endpoint'),
8513            healthy=d.get('healthy'),
8514            id=d.get('id'),
8515            name=d.get('name'),
8516            port=d.get('port'),
8517            port_override=d.get('port_override'),
8518            region=d.get('region'),
8519            role_arn=d.get('role_arn'),
8520            role_external_id=d.get('role_external_id'),
8521            secret_access_key=d.get('secret_access_key'),
8522            secret_store_id=d.get('secret_store_id'),
8523            tags=d.get('tags'),
8524        )
NeptuneIAM( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
8413    def __init__(
8414        self,
8415        access_key=None,
8416        bind_interface=None,
8417        egress_filter=None,
8418        endpoint=None,
8419        healthy=None,
8420        id=None,
8421        name=None,
8422        port=None,
8423        port_override=None,
8424        region=None,
8425        role_arn=None,
8426        role_external_id=None,
8427        secret_access_key=None,
8428        secret_store_id=None,
8429        tags=None,
8430    ):
8431        self.access_key = access_key if access_key is not None else ''
8432        self.bind_interface = bind_interface if bind_interface is not None else ''
8433        '''
8434         Bind interface
8435        '''
8436        self.egress_filter = egress_filter if egress_filter is not None else ''
8437        '''
8438         A filter applied to the routing logic to pin datasource to nodes.
8439        '''
8440        self.endpoint = endpoint if endpoint is not None else ''
8441        self.healthy = healthy if healthy is not None else False
8442        '''
8443         True if the datasource is reachable and the credentials are valid.
8444        '''
8445        self.id = id if id is not None else ''
8446        '''
8447         Unique identifier of the Resource.
8448        '''
8449        self.name = name if name is not None else ''
8450        '''
8451         Unique human-readable name of the Resource.
8452        '''
8453        self.port = port if port is not None else 0
8454        self.port_override = port_override if port_override is not None else 0
8455        self.region = region if region is not None else ''
8456        self.role_arn = role_arn if role_arn is not None else ''
8457        self.role_external_id = role_external_id if role_external_id is not None else ''
8458        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
8459        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8460        '''
8461         ID of the secret store containing credentials for this resource, if any.
8462        '''
8463        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8464        '''
8465         Tags is a map of key, value pairs.
8466        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
8487    def to_dict(self):
8488        return {
8489            'access_key': self.access_key,
8490            'bind_interface': self.bind_interface,
8491            'egress_filter': self.egress_filter,
8492            'endpoint': self.endpoint,
8493            'healthy': self.healthy,
8494            'id': self.id,
8495            'name': self.name,
8496            'port': self.port,
8497            'port_override': self.port_override,
8498            'region': self.region,
8499            'role_arn': self.role_arn,
8500            'role_external_id': self.role_external_id,
8501            'secret_access_key': self.secret_access_key,
8502            'secret_store_id': self.secret_store_id,
8503            'tags': self.tags,
8504        }
@classmethod
def from_dict(cls, d)
8506    @classmethod
8507    def from_dict(cls, d):
8508        return cls(
8509            access_key=d.get('access_key'),
8510            bind_interface=d.get('bind_interface'),
8511            egress_filter=d.get('egress_filter'),
8512            endpoint=d.get('endpoint'),
8513            healthy=d.get('healthy'),
8514            id=d.get('id'),
8515            name=d.get('name'),
8516            port=d.get('port'),
8517            port_override=d.get('port_override'),
8518            region=d.get('region'),
8519            role_arn=d.get('role_arn'),
8520            role_external_id=d.get('role_external_id'),
8521            secret_access_key=d.get('secret_access_key'),
8522            secret_store_id=d.get('secret_store_id'),
8523            tags=d.get('tags'),
8524        )
class NodeCreateResponse:
8527class NodeCreateResponse:
8528    '''
8529         NodeCreateResponse reports how the Nodes were created in the system.
8530    '''
8531    __slots__ = [
8532        'meta',
8533        'node',
8534        'rate_limit',
8535        'token',
8536    ]
8537
8538    def __init__(
8539        self,
8540        meta=None,
8541        node=None,
8542        rate_limit=None,
8543        token=None,
8544    ):
8545        self.meta = meta if meta is not None else None
8546        '''
8547         Reserved for future use.
8548        '''
8549        self.node = node if node is not None else None
8550        '''
8551         The created Node.
8552        '''
8553        self.rate_limit = rate_limit if rate_limit is not None else None
8554        '''
8555         Rate limit information.
8556        '''
8557        self.token = token if token is not None else ''
8558        '''
8559         The auth token generated for the Node. The Node will use this token to
8560         authenticate with the strongDM API.
8561        '''
8562
8563    def __repr__(self):
8564        return '<sdm.NodeCreateResponse ' + \
8565            'meta: ' + repr(self.meta) + ' ' +\
8566            'node: ' + repr(self.node) + ' ' +\
8567            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8568            'token: ' + repr(self.token) + ' ' +\
8569            '>'
8570
8571    def to_dict(self):
8572        return {
8573            'meta': self.meta,
8574            'node': self.node,
8575            'rate_limit': self.rate_limit,
8576            'token': self.token,
8577        }
8578
8579    @classmethod
8580    def from_dict(cls, d):
8581        return cls(
8582            meta=d.get('meta'),
8583            node=d.get('node'),
8584            rate_limit=d.get('rate_limit'),
8585            token=d.get('token'),
8586        )

NodeCreateResponse reports how the Nodes were created in the system.

NodeCreateResponse(meta=None, node=None, rate_limit=None, token=None)
8538    def __init__(
8539        self,
8540        meta=None,
8541        node=None,
8542        rate_limit=None,
8543        token=None,
8544    ):
8545        self.meta = meta if meta is not None else None
8546        '''
8547         Reserved for future use.
8548        '''
8549        self.node = node if node is not None else None
8550        '''
8551         The created Node.
8552        '''
8553        self.rate_limit = rate_limit if rate_limit is not None else None
8554        '''
8555         Rate limit information.
8556        '''
8557        self.token = token if token is not None else ''
8558        '''
8559         The auth token generated for the Node. The Node will use this token to
8560         authenticate with the strongDM API.
8561        '''
meta

Reserved for future use.

node

The created Node.

rate_limit

Rate limit information.

token

The auth token generated for the Node. The Node will use this token to authenticate with the strongDM API.

def to_dict(self)
8571    def to_dict(self):
8572        return {
8573            'meta': self.meta,
8574            'node': self.node,
8575            'rate_limit': self.rate_limit,
8576            'token': self.token,
8577        }
@classmethod
def from_dict(cls, d)
8579    @classmethod
8580    def from_dict(cls, d):
8581        return cls(
8582            meta=d.get('meta'),
8583            node=d.get('node'),
8584            rate_limit=d.get('rate_limit'),
8585            token=d.get('token'),
8586        )
class NodeDeleteResponse:
8589class NodeDeleteResponse:
8590    '''
8591         NodeDeleteResponse returns information about a Node that was deleted.
8592    '''
8593    __slots__ = [
8594        'meta',
8595        'rate_limit',
8596    ]
8597
8598    def __init__(
8599        self,
8600        meta=None,
8601        rate_limit=None,
8602    ):
8603        self.meta = meta if meta is not None else None
8604        '''
8605         Reserved for future use.
8606        '''
8607        self.rate_limit = rate_limit if rate_limit is not None else None
8608        '''
8609         Rate limit information.
8610        '''
8611
8612    def __repr__(self):
8613        return '<sdm.NodeDeleteResponse ' + \
8614            'meta: ' + repr(self.meta) + ' ' +\
8615            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8616            '>'
8617
8618    def to_dict(self):
8619        return {
8620            'meta': self.meta,
8621            'rate_limit': self.rate_limit,
8622        }
8623
8624    @classmethod
8625    def from_dict(cls, d):
8626        return cls(
8627            meta=d.get('meta'),
8628            rate_limit=d.get('rate_limit'),
8629        )

NodeDeleteResponse returns information about a Node that was deleted.

NodeDeleteResponse(meta=None, rate_limit=None)
8598    def __init__(
8599        self,
8600        meta=None,
8601        rate_limit=None,
8602    ):
8603        self.meta = meta if meta is not None else None
8604        '''
8605         Reserved for future use.
8606        '''
8607        self.rate_limit = rate_limit if rate_limit is not None else None
8608        '''
8609         Rate limit information.
8610        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
8618    def to_dict(self):
8619        return {
8620            'meta': self.meta,
8621            'rate_limit': self.rate_limit,
8622        }
@classmethod
def from_dict(cls, d)
8624    @classmethod
8625    def from_dict(cls, d):
8626        return cls(
8627            meta=d.get('meta'),
8628            rate_limit=d.get('rate_limit'),
8629        )
class NodeGetResponse:
8632class NodeGetResponse:
8633    '''
8634         NodeGetResponse returns a requested Node.
8635    '''
8636    __slots__ = [
8637        'meta',
8638        'node',
8639        'rate_limit',
8640    ]
8641
8642    def __init__(
8643        self,
8644        meta=None,
8645        node=None,
8646        rate_limit=None,
8647    ):
8648        self.meta = meta if meta is not None else None
8649        '''
8650         Reserved for future use.
8651        '''
8652        self.node = node if node is not None else None
8653        '''
8654         The requested Node.
8655        '''
8656        self.rate_limit = rate_limit if rate_limit is not None else None
8657        '''
8658         Rate limit information.
8659        '''
8660
8661    def __repr__(self):
8662        return '<sdm.NodeGetResponse ' + \
8663            'meta: ' + repr(self.meta) + ' ' +\
8664            'node: ' + repr(self.node) + ' ' +\
8665            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8666            '>'
8667
8668    def to_dict(self):
8669        return {
8670            'meta': self.meta,
8671            'node': self.node,
8672            'rate_limit': self.rate_limit,
8673        }
8674
8675    @classmethod
8676    def from_dict(cls, d):
8677        return cls(
8678            meta=d.get('meta'),
8679            node=d.get('node'),
8680            rate_limit=d.get('rate_limit'),
8681        )

NodeGetResponse returns a requested Node.

NodeGetResponse(meta=None, node=None, rate_limit=None)
8642    def __init__(
8643        self,
8644        meta=None,
8645        node=None,
8646        rate_limit=None,
8647    ):
8648        self.meta = meta if meta is not None else None
8649        '''
8650         Reserved for future use.
8651        '''
8652        self.node = node if node is not None else None
8653        '''
8654         The requested Node.
8655        '''
8656        self.rate_limit = rate_limit if rate_limit is not None else None
8657        '''
8658         Rate limit information.
8659        '''
meta

Reserved for future use.

node

The requested Node.

rate_limit

Rate limit information.

def to_dict(self)
8668    def to_dict(self):
8669        return {
8670            'meta': self.meta,
8671            'node': self.node,
8672            'rate_limit': self.rate_limit,
8673        }
@classmethod
def from_dict(cls, d)
8675    @classmethod
8676    def from_dict(cls, d):
8677        return cls(
8678            meta=d.get('meta'),
8679            node=d.get('node'),
8680            rate_limit=d.get('rate_limit'),
8681        )
class NodeUpdateResponse:
8684class NodeUpdateResponse:
8685    '''
8686         NodeUpdateResponse returns the fields of a Node after it has been updated by
8687     a NodeUpdateRequest.
8688    '''
8689    __slots__ = [
8690        'meta',
8691        'node',
8692        'rate_limit',
8693    ]
8694
8695    def __init__(
8696        self,
8697        meta=None,
8698        node=None,
8699        rate_limit=None,
8700    ):
8701        self.meta = meta if meta is not None else None
8702        '''
8703         Reserved for future use.
8704        '''
8705        self.node = node if node is not None else None
8706        '''
8707         The updated Node.
8708        '''
8709        self.rate_limit = rate_limit if rate_limit is not None else None
8710        '''
8711         Rate limit information.
8712        '''
8713
8714    def __repr__(self):
8715        return '<sdm.NodeUpdateResponse ' + \
8716            'meta: ' + repr(self.meta) + ' ' +\
8717            'node: ' + repr(self.node) + ' ' +\
8718            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8719            '>'
8720
8721    def to_dict(self):
8722        return {
8723            'meta': self.meta,
8724            'node': self.node,
8725            'rate_limit': self.rate_limit,
8726        }
8727
8728    @classmethod
8729    def from_dict(cls, d):
8730        return cls(
8731            meta=d.get('meta'),
8732            node=d.get('node'),
8733            rate_limit=d.get('rate_limit'),
8734        )

NodeUpdateResponse returns the fields of a Node after it has been updated by a NodeUpdateRequest.

NodeUpdateResponse(meta=None, node=None, rate_limit=None)
8695    def __init__(
8696        self,
8697        meta=None,
8698        node=None,
8699        rate_limit=None,
8700    ):
8701        self.meta = meta if meta is not None else None
8702        '''
8703         Reserved for future use.
8704        '''
8705        self.node = node if node is not None else None
8706        '''
8707         The updated Node.
8708        '''
8709        self.rate_limit = rate_limit if rate_limit is not None else None
8710        '''
8711         Rate limit information.
8712        '''
meta

Reserved for future use.

node

The updated Node.

rate_limit

Rate limit information.

def to_dict(self)
8721    def to_dict(self):
8722        return {
8723            'meta': self.meta,
8724            'node': self.node,
8725            'rate_limit': self.rate_limit,
8726        }
@classmethod
def from_dict(cls, d)
8728    @classmethod
8729    def from_dict(cls, d):
8730        return cls(
8731            meta=d.get('meta'),
8732            node=d.get('node'),
8733            rate_limit=d.get('rate_limit'),
8734        )
class Oracle:
8737class Oracle:
8738    __slots__ = [
8739        'bind_interface',
8740        'database',
8741        'egress_filter',
8742        'healthy',
8743        'hostname',
8744        'id',
8745        'name',
8746        'password',
8747        'port',
8748        'port_override',
8749        'secret_store_id',
8750        'tags',
8751        'tls_required',
8752        'username',
8753    ]
8754
8755    def __init__(
8756        self,
8757        bind_interface=None,
8758        database=None,
8759        egress_filter=None,
8760        healthy=None,
8761        hostname=None,
8762        id=None,
8763        name=None,
8764        password=None,
8765        port=None,
8766        port_override=None,
8767        secret_store_id=None,
8768        tags=None,
8769        tls_required=None,
8770        username=None,
8771    ):
8772        self.bind_interface = bind_interface if bind_interface is not None else ''
8773        '''
8774         Bind interface
8775        '''
8776        self.database = database if database is not None else ''
8777        self.egress_filter = egress_filter if egress_filter is not None else ''
8778        '''
8779         A filter applied to the routing logic to pin datasource to nodes.
8780        '''
8781        self.healthy = healthy if healthy is not None else False
8782        '''
8783         True if the datasource is reachable and the credentials are valid.
8784        '''
8785        self.hostname = hostname if hostname is not None else ''
8786        self.id = id if id is not None else ''
8787        '''
8788         Unique identifier of the Resource.
8789        '''
8790        self.name = name if name is not None else ''
8791        '''
8792         Unique human-readable name of the Resource.
8793        '''
8794        self.password = password if password is not None else ''
8795        self.port = port if port is not None else 0
8796        self.port_override = port_override if port_override is not None else 0
8797        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8798        '''
8799         ID of the secret store containing credentials for this resource, if any.
8800        '''
8801        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8802        '''
8803         Tags is a map of key, value pairs.
8804        '''
8805        self.tls_required = tls_required if tls_required is not None else False
8806        self.username = username if username is not None else ''
8807
8808    def __repr__(self):
8809        return '<sdm.Oracle ' + \
8810            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8811            'database: ' + repr(self.database) + ' ' +\
8812            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8813            'healthy: ' + repr(self.healthy) + ' ' +\
8814            'hostname: ' + repr(self.hostname) + ' ' +\
8815            'id: ' + repr(self.id) + ' ' +\
8816            'name: ' + repr(self.name) + ' ' +\
8817            'password: ' + repr(self.password) + ' ' +\
8818            'port: ' + repr(self.port) + ' ' +\
8819            'port_override: ' + repr(self.port_override) + ' ' +\
8820            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8821            'tags: ' + repr(self.tags) + ' ' +\
8822            'tls_required: ' + repr(self.tls_required) + ' ' +\
8823            'username: ' + repr(self.username) + ' ' +\
8824            '>'
8825
8826    def to_dict(self):
8827        return {
8828            'bind_interface': self.bind_interface,
8829            'database': self.database,
8830            'egress_filter': self.egress_filter,
8831            'healthy': self.healthy,
8832            'hostname': self.hostname,
8833            'id': self.id,
8834            'name': self.name,
8835            'password': self.password,
8836            'port': self.port,
8837            'port_override': self.port_override,
8838            'secret_store_id': self.secret_store_id,
8839            'tags': self.tags,
8840            'tls_required': self.tls_required,
8841            'username': self.username,
8842        }
8843
8844    @classmethod
8845    def from_dict(cls, d):
8846        return cls(
8847            bind_interface=d.get('bind_interface'),
8848            database=d.get('database'),
8849            egress_filter=d.get('egress_filter'),
8850            healthy=d.get('healthy'),
8851            hostname=d.get('hostname'),
8852            id=d.get('id'),
8853            name=d.get('name'),
8854            password=d.get('password'),
8855            port=d.get('port'),
8856            port_override=d.get('port_override'),
8857            secret_store_id=d.get('secret_store_id'),
8858            tags=d.get('tags'),
8859            tls_required=d.get('tls_required'),
8860            username=d.get('username'),
8861        )
Oracle( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8755    def __init__(
8756        self,
8757        bind_interface=None,
8758        database=None,
8759        egress_filter=None,
8760        healthy=None,
8761        hostname=None,
8762        id=None,
8763        name=None,
8764        password=None,
8765        port=None,
8766        port_override=None,
8767        secret_store_id=None,
8768        tags=None,
8769        tls_required=None,
8770        username=None,
8771    ):
8772        self.bind_interface = bind_interface if bind_interface is not None else ''
8773        '''
8774         Bind interface
8775        '''
8776        self.database = database if database is not None else ''
8777        self.egress_filter = egress_filter if egress_filter is not None else ''
8778        '''
8779         A filter applied to the routing logic to pin datasource to nodes.
8780        '''
8781        self.healthy = healthy if healthy is not None else False
8782        '''
8783         True if the datasource is reachable and the credentials are valid.
8784        '''
8785        self.hostname = hostname if hostname is not None else ''
8786        self.id = id if id is not None else ''
8787        '''
8788         Unique identifier of the Resource.
8789        '''
8790        self.name = name if name is not None else ''
8791        '''
8792         Unique human-readable name of the Resource.
8793        '''
8794        self.password = password if password is not None else ''
8795        self.port = port if port is not None else 0
8796        self.port_override = port_override if port_override is not None else 0
8797        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8798        '''
8799         ID of the secret store containing credentials for this resource, if any.
8800        '''
8801        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8802        '''
8803         Tags is a map of key, value pairs.
8804        '''
8805        self.tls_required = tls_required if tls_required is not None else False
8806        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8826    def to_dict(self):
8827        return {
8828            'bind_interface': self.bind_interface,
8829            'database': self.database,
8830            'egress_filter': self.egress_filter,
8831            'healthy': self.healthy,
8832            'hostname': self.hostname,
8833            'id': self.id,
8834            'name': self.name,
8835            'password': self.password,
8836            'port': self.port,
8837            'port_override': self.port_override,
8838            'secret_store_id': self.secret_store_id,
8839            'tags': self.tags,
8840            'tls_required': self.tls_required,
8841            'username': self.username,
8842        }
@classmethod
def from_dict(cls, d)
8844    @classmethod
8845    def from_dict(cls, d):
8846        return cls(
8847            bind_interface=d.get('bind_interface'),
8848            database=d.get('database'),
8849            egress_filter=d.get('egress_filter'),
8850            healthy=d.get('healthy'),
8851            hostname=d.get('hostname'),
8852            id=d.get('id'),
8853            name=d.get('name'),
8854            password=d.get('password'),
8855            port=d.get('port'),
8856            port_override=d.get('port_override'),
8857            secret_store_id=d.get('secret_store_id'),
8858            tags=d.get('tags'),
8859            tls_required=d.get('tls_required'),
8860            username=d.get('username'),
8861        )
class Postgres:
8864class Postgres:
8865    __slots__ = [
8866        'bind_interface',
8867        'database',
8868        'egress_filter',
8869        'healthy',
8870        'hostname',
8871        'id',
8872        'name',
8873        'override_database',
8874        'password',
8875        'port',
8876        'port_override',
8877        'secret_store_id',
8878        'tags',
8879        'username',
8880    ]
8881
8882    def __init__(
8883        self,
8884        bind_interface=None,
8885        database=None,
8886        egress_filter=None,
8887        healthy=None,
8888        hostname=None,
8889        id=None,
8890        name=None,
8891        override_database=None,
8892        password=None,
8893        port=None,
8894        port_override=None,
8895        secret_store_id=None,
8896        tags=None,
8897        username=None,
8898    ):
8899        self.bind_interface = bind_interface if bind_interface is not None else ''
8900        '''
8901         Bind interface
8902        '''
8903        self.database = database if database is not None else ''
8904        self.egress_filter = egress_filter if egress_filter is not None else ''
8905        '''
8906         A filter applied to the routing logic to pin datasource to nodes.
8907        '''
8908        self.healthy = healthy if healthy is not None else False
8909        '''
8910         True if the datasource is reachable and the credentials are valid.
8911        '''
8912        self.hostname = hostname if hostname is not None else ''
8913        self.id = id if id is not None else ''
8914        '''
8915         Unique identifier of the Resource.
8916        '''
8917        self.name = name if name is not None else ''
8918        '''
8919         Unique human-readable name of the Resource.
8920        '''
8921        self.override_database = override_database if override_database is not None else False
8922        self.password = password if password is not None else ''
8923        self.port = port if port is not None else 0
8924        self.port_override = port_override if port_override is not None else 0
8925        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8926        '''
8927         ID of the secret store containing credentials for this resource, if any.
8928        '''
8929        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8930        '''
8931         Tags is a map of key, value pairs.
8932        '''
8933        self.username = username if username is not None else ''
8934
8935    def __repr__(self):
8936        return '<sdm.Postgres ' + \
8937            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8938            'database: ' + repr(self.database) + ' ' +\
8939            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8940            'healthy: ' + repr(self.healthy) + ' ' +\
8941            'hostname: ' + repr(self.hostname) + ' ' +\
8942            'id: ' + repr(self.id) + ' ' +\
8943            'name: ' + repr(self.name) + ' ' +\
8944            'override_database: ' + repr(self.override_database) + ' ' +\
8945            'password: ' + repr(self.password) + ' ' +\
8946            'port: ' + repr(self.port) + ' ' +\
8947            'port_override: ' + repr(self.port_override) + ' ' +\
8948            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8949            'tags: ' + repr(self.tags) + ' ' +\
8950            'username: ' + repr(self.username) + ' ' +\
8951            '>'
8952
8953    def to_dict(self):
8954        return {
8955            'bind_interface': self.bind_interface,
8956            'database': self.database,
8957            'egress_filter': self.egress_filter,
8958            'healthy': self.healthy,
8959            'hostname': self.hostname,
8960            'id': self.id,
8961            'name': self.name,
8962            'override_database': self.override_database,
8963            'password': self.password,
8964            'port': self.port,
8965            'port_override': self.port_override,
8966            'secret_store_id': self.secret_store_id,
8967            'tags': self.tags,
8968            'username': self.username,
8969        }
8970
8971    @classmethod
8972    def from_dict(cls, d):
8973        return cls(
8974            bind_interface=d.get('bind_interface'),
8975            database=d.get('database'),
8976            egress_filter=d.get('egress_filter'),
8977            healthy=d.get('healthy'),
8978            hostname=d.get('hostname'),
8979            id=d.get('id'),
8980            name=d.get('name'),
8981            override_database=d.get('override_database'),
8982            password=d.get('password'),
8983            port=d.get('port'),
8984            port_override=d.get('port_override'),
8985            secret_store_id=d.get('secret_store_id'),
8986            tags=d.get('tags'),
8987            username=d.get('username'),
8988        )
Postgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
8882    def __init__(
8883        self,
8884        bind_interface=None,
8885        database=None,
8886        egress_filter=None,
8887        healthy=None,
8888        hostname=None,
8889        id=None,
8890        name=None,
8891        override_database=None,
8892        password=None,
8893        port=None,
8894        port_override=None,
8895        secret_store_id=None,
8896        tags=None,
8897        username=None,
8898    ):
8899        self.bind_interface = bind_interface if bind_interface is not None else ''
8900        '''
8901         Bind interface
8902        '''
8903        self.database = database if database is not None else ''
8904        self.egress_filter = egress_filter if egress_filter is not None else ''
8905        '''
8906         A filter applied to the routing logic to pin datasource to nodes.
8907        '''
8908        self.healthy = healthy if healthy is not None else False
8909        '''
8910         True if the datasource is reachable and the credentials are valid.
8911        '''
8912        self.hostname = hostname if hostname is not None else ''
8913        self.id = id if id is not None else ''
8914        '''
8915         Unique identifier of the Resource.
8916        '''
8917        self.name = name if name is not None else ''
8918        '''
8919         Unique human-readable name of the Resource.
8920        '''
8921        self.override_database = override_database if override_database is not None else False
8922        self.password = password if password is not None else ''
8923        self.port = port if port is not None else 0
8924        self.port_override = port_override if port_override is not None else 0
8925        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8926        '''
8927         ID of the secret store containing credentials for this resource, if any.
8928        '''
8929        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8930        '''
8931         Tags is a map of key, value pairs.
8932        '''
8933        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
8953    def to_dict(self):
8954        return {
8955            'bind_interface': self.bind_interface,
8956            'database': self.database,
8957            'egress_filter': self.egress_filter,
8958            'healthy': self.healthy,
8959            'hostname': self.hostname,
8960            'id': self.id,
8961            'name': self.name,
8962            'override_database': self.override_database,
8963            'password': self.password,
8964            'port': self.port,
8965            'port_override': self.port_override,
8966            'secret_store_id': self.secret_store_id,
8967            'tags': self.tags,
8968            'username': self.username,
8969        }
@classmethod
def from_dict(cls, d)
8971    @classmethod
8972    def from_dict(cls, d):
8973        return cls(
8974            bind_interface=d.get('bind_interface'),
8975            database=d.get('database'),
8976            egress_filter=d.get('egress_filter'),
8977            healthy=d.get('healthy'),
8978            hostname=d.get('hostname'),
8979            id=d.get('id'),
8980            name=d.get('name'),
8981            override_database=d.get('override_database'),
8982            password=d.get('password'),
8983            port=d.get('port'),
8984            port_override=d.get('port_override'),
8985            secret_store_id=d.get('secret_store_id'),
8986            tags=d.get('tags'),
8987            username=d.get('username'),
8988        )
class Presto:
8991class Presto:
8992    __slots__ = [
8993        'bind_interface',
8994        'database',
8995        'egress_filter',
8996        'healthy',
8997        'hostname',
8998        'id',
8999        'name',
9000        'password',
9001        'port',
9002        'port_override',
9003        'secret_store_id',
9004        'tags',
9005        'tls_required',
9006        'username',
9007    ]
9008
9009    def __init__(
9010        self,
9011        bind_interface=None,
9012        database=None,
9013        egress_filter=None,
9014        healthy=None,
9015        hostname=None,
9016        id=None,
9017        name=None,
9018        password=None,
9019        port=None,
9020        port_override=None,
9021        secret_store_id=None,
9022        tags=None,
9023        tls_required=None,
9024        username=None,
9025    ):
9026        self.bind_interface = bind_interface if bind_interface is not None else ''
9027        '''
9028         Bind interface
9029        '''
9030        self.database = database if database is not None else ''
9031        self.egress_filter = egress_filter if egress_filter is not None else ''
9032        '''
9033         A filter applied to the routing logic to pin datasource to nodes.
9034        '''
9035        self.healthy = healthy if healthy is not None else False
9036        '''
9037         True if the datasource is reachable and the credentials are valid.
9038        '''
9039        self.hostname = hostname if hostname is not None else ''
9040        self.id = id if id is not None else ''
9041        '''
9042         Unique identifier of the Resource.
9043        '''
9044        self.name = name if name is not None else ''
9045        '''
9046         Unique human-readable name of the Resource.
9047        '''
9048        self.password = password if password is not None else ''
9049        self.port = port if port is not None else 0
9050        self.port_override = port_override if port_override is not None else 0
9051        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9052        '''
9053         ID of the secret store containing credentials for this resource, if any.
9054        '''
9055        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9056        '''
9057         Tags is a map of key, value pairs.
9058        '''
9059        self.tls_required = tls_required if tls_required is not None else False
9060        self.username = username if username is not None else ''
9061
9062    def __repr__(self):
9063        return '<sdm.Presto ' + \
9064            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9065            'database: ' + repr(self.database) + ' ' +\
9066            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9067            'healthy: ' + repr(self.healthy) + ' ' +\
9068            'hostname: ' + repr(self.hostname) + ' ' +\
9069            'id: ' + repr(self.id) + ' ' +\
9070            'name: ' + repr(self.name) + ' ' +\
9071            'password: ' + repr(self.password) + ' ' +\
9072            'port: ' + repr(self.port) + ' ' +\
9073            'port_override: ' + repr(self.port_override) + ' ' +\
9074            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9075            'tags: ' + repr(self.tags) + ' ' +\
9076            'tls_required: ' + repr(self.tls_required) + ' ' +\
9077            'username: ' + repr(self.username) + ' ' +\
9078            '>'
9079
9080    def to_dict(self):
9081        return {
9082            'bind_interface': self.bind_interface,
9083            'database': self.database,
9084            'egress_filter': self.egress_filter,
9085            'healthy': self.healthy,
9086            'hostname': self.hostname,
9087            'id': self.id,
9088            'name': self.name,
9089            'password': self.password,
9090            'port': self.port,
9091            'port_override': self.port_override,
9092            'secret_store_id': self.secret_store_id,
9093            'tags': self.tags,
9094            'tls_required': self.tls_required,
9095            'username': self.username,
9096        }
9097
9098    @classmethod
9099    def from_dict(cls, d):
9100        return cls(
9101            bind_interface=d.get('bind_interface'),
9102            database=d.get('database'),
9103            egress_filter=d.get('egress_filter'),
9104            healthy=d.get('healthy'),
9105            hostname=d.get('hostname'),
9106            id=d.get('id'),
9107            name=d.get('name'),
9108            password=d.get('password'),
9109            port=d.get('port'),
9110            port_override=d.get('port_override'),
9111            secret_store_id=d.get('secret_store_id'),
9112            tags=d.get('tags'),
9113            tls_required=d.get('tls_required'),
9114            username=d.get('username'),
9115        )
Presto( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
9009    def __init__(
9010        self,
9011        bind_interface=None,
9012        database=None,
9013        egress_filter=None,
9014        healthy=None,
9015        hostname=None,
9016        id=None,
9017        name=None,
9018        password=None,
9019        port=None,
9020        port_override=None,
9021        secret_store_id=None,
9022        tags=None,
9023        tls_required=None,
9024        username=None,
9025    ):
9026        self.bind_interface = bind_interface if bind_interface is not None else ''
9027        '''
9028         Bind interface
9029        '''
9030        self.database = database if database is not None else ''
9031        self.egress_filter = egress_filter if egress_filter is not None else ''
9032        '''
9033         A filter applied to the routing logic to pin datasource to nodes.
9034        '''
9035        self.healthy = healthy if healthy is not None else False
9036        '''
9037         True if the datasource is reachable and the credentials are valid.
9038        '''
9039        self.hostname = hostname if hostname is not None else ''
9040        self.id = id if id is not None else ''
9041        '''
9042         Unique identifier of the Resource.
9043        '''
9044        self.name = name if name is not None else ''
9045        '''
9046         Unique human-readable name of the Resource.
9047        '''
9048        self.password = password if password is not None else ''
9049        self.port = port if port is not None else 0
9050        self.port_override = port_override if port_override is not None else 0
9051        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9052        '''
9053         ID of the secret store containing credentials for this resource, if any.
9054        '''
9055        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9056        '''
9057         Tags is a map of key, value pairs.
9058        '''
9059        self.tls_required = tls_required if tls_required is not None else False
9060        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
9080    def to_dict(self):
9081        return {
9082            'bind_interface': self.bind_interface,
9083            'database': self.database,
9084            'egress_filter': self.egress_filter,
9085            'healthy': self.healthy,
9086            'hostname': self.hostname,
9087            'id': self.id,
9088            'name': self.name,
9089            'password': self.password,
9090            'port': self.port,
9091            'port_override': self.port_override,
9092            'secret_store_id': self.secret_store_id,
9093            'tags': self.tags,
9094            'tls_required': self.tls_required,
9095            'username': self.username,
9096        }
@classmethod
def from_dict(cls, d)
9098    @classmethod
9099    def from_dict(cls, d):
9100        return cls(
9101            bind_interface=d.get('bind_interface'),
9102            database=d.get('database'),
9103            egress_filter=d.get('egress_filter'),
9104            healthy=d.get('healthy'),
9105            hostname=d.get('hostname'),
9106            id=d.get('id'),
9107            name=d.get('name'),
9108            password=d.get('password'),
9109            port=d.get('port'),
9110            port_override=d.get('port_override'),
9111            secret_store_id=d.get('secret_store_id'),
9112            tags=d.get('tags'),
9113            tls_required=d.get('tls_required'),
9114            username=d.get('username'),
9115        )
class RDP:
9118class RDP:
9119    __slots__ = [
9120        'bind_interface',
9121        'downgrade_nla_connections',
9122        'egress_filter',
9123        'healthy',
9124        'hostname',
9125        'id',
9126        'name',
9127        'password',
9128        'port',
9129        'port_override',
9130        'secret_store_id',
9131        'tags',
9132        'username',
9133    ]
9134
9135    def __init__(
9136        self,
9137        bind_interface=None,
9138        downgrade_nla_connections=None,
9139        egress_filter=None,
9140        healthy=None,
9141        hostname=None,
9142        id=None,
9143        name=None,
9144        password=None,
9145        port=None,
9146        port_override=None,
9147        secret_store_id=None,
9148        tags=None,
9149        username=None,
9150    ):
9151        self.bind_interface = bind_interface if bind_interface is not None else ''
9152        '''
9153         Bind interface
9154        '''
9155        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
9156        self.egress_filter = egress_filter if egress_filter is not None else ''
9157        '''
9158         A filter applied to the routing logic to pin datasource to nodes.
9159        '''
9160        self.healthy = healthy if healthy is not None else False
9161        '''
9162         True if the datasource is reachable and the credentials are valid.
9163        '''
9164        self.hostname = hostname if hostname is not None else ''
9165        self.id = id if id is not None else ''
9166        '''
9167         Unique identifier of the Resource.
9168        '''
9169        self.name = name if name is not None else ''
9170        '''
9171         Unique human-readable name of the Resource.
9172        '''
9173        self.password = password if password is not None else ''
9174        self.port = port if port is not None else 0
9175        self.port_override = port_override if port_override is not None else 0
9176        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9177        '''
9178         ID of the secret store containing credentials for this resource, if any.
9179        '''
9180        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9181        '''
9182         Tags is a map of key, value pairs.
9183        '''
9184        self.username = username if username is not None else ''
9185
9186    def __repr__(self):
9187        return '<sdm.RDP ' + \
9188            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9189            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
9190            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9191            'healthy: ' + repr(self.healthy) + ' ' +\
9192            'hostname: ' + repr(self.hostname) + ' ' +\
9193            'id: ' + repr(self.id) + ' ' +\
9194            'name: ' + repr(self.name) + ' ' +\
9195            'password: ' + repr(self.password) + ' ' +\
9196            'port: ' + repr(self.port) + ' ' +\
9197            'port_override: ' + repr(self.port_override) + ' ' +\
9198            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9199            'tags: ' + repr(self.tags) + ' ' +\
9200            'username: ' + repr(self.username) + ' ' +\
9201            '>'
9202
9203    def to_dict(self):
9204        return {
9205            'bind_interface': self.bind_interface,
9206            'downgrade_nla_connections': self.downgrade_nla_connections,
9207            'egress_filter': self.egress_filter,
9208            'healthy': self.healthy,
9209            'hostname': self.hostname,
9210            'id': self.id,
9211            'name': self.name,
9212            'password': self.password,
9213            'port': self.port,
9214            'port_override': self.port_override,
9215            'secret_store_id': self.secret_store_id,
9216            'tags': self.tags,
9217            'username': self.username,
9218        }
9219
9220    @classmethod
9221    def from_dict(cls, d):
9222        return cls(
9223            bind_interface=d.get('bind_interface'),
9224            downgrade_nla_connections=d.get('downgrade_nla_connections'),
9225            egress_filter=d.get('egress_filter'),
9226            healthy=d.get('healthy'),
9227            hostname=d.get('hostname'),
9228            id=d.get('id'),
9229            name=d.get('name'),
9230            password=d.get('password'),
9231            port=d.get('port'),
9232            port_override=d.get('port_override'),
9233            secret_store_id=d.get('secret_store_id'),
9234            tags=d.get('tags'),
9235            username=d.get('username'),
9236        )
RDP( bind_interface=None, downgrade_nla_connections=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
9135    def __init__(
9136        self,
9137        bind_interface=None,
9138        downgrade_nla_connections=None,
9139        egress_filter=None,
9140        healthy=None,
9141        hostname=None,
9142        id=None,
9143        name=None,
9144        password=None,
9145        port=None,
9146        port_override=None,
9147        secret_store_id=None,
9148        tags=None,
9149        username=None,
9150    ):
9151        self.bind_interface = bind_interface if bind_interface is not None else ''
9152        '''
9153         Bind interface
9154        '''
9155        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
9156        self.egress_filter = egress_filter if egress_filter is not None else ''
9157        '''
9158         A filter applied to the routing logic to pin datasource to nodes.
9159        '''
9160        self.healthy = healthy if healthy is not None else False
9161        '''
9162         True if the datasource is reachable and the credentials are valid.
9163        '''
9164        self.hostname = hostname if hostname is not None else ''
9165        self.id = id if id is not None else ''
9166        '''
9167         Unique identifier of the Resource.
9168        '''
9169        self.name = name if name is not None else ''
9170        '''
9171         Unique human-readable name of the Resource.
9172        '''
9173        self.password = password if password is not None else ''
9174        self.port = port if port is not None else 0
9175        self.port_override = port_override if port_override is not None else 0
9176        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9177        '''
9178         ID of the secret store containing credentials for this resource, if any.
9179        '''
9180        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9181        '''
9182         Tags is a map of key, value pairs.
9183        '''
9184        self.username = username if username is not None else ''
bind_interface

Bind interface

downgrade_nla_connections
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
9203    def to_dict(self):
9204        return {
9205            'bind_interface': self.bind_interface,
9206            'downgrade_nla_connections': self.downgrade_nla_connections,
9207            'egress_filter': self.egress_filter,
9208            'healthy': self.healthy,
9209            'hostname': self.hostname,
9210            'id': self.id,
9211            'name': self.name,
9212            'password': self.password,
9213            'port': self.port,
9214            'port_override': self.port_override,
9215            'secret_store_id': self.secret_store_id,
9216            'tags': self.tags,
9217            'username': self.username,
9218        }
@classmethod
def from_dict(cls, d)
9220    @classmethod
9221    def from_dict(cls, d):
9222        return cls(
9223            bind_interface=d.get('bind_interface'),
9224            downgrade_nla_connections=d.get('downgrade_nla_connections'),
9225            egress_filter=d.get('egress_filter'),
9226            healthy=d.get('healthy'),
9227            hostname=d.get('hostname'),
9228            id=d.get('id'),
9229            name=d.get('name'),
9230            password=d.get('password'),
9231            port=d.get('port'),
9232            port_override=d.get('port_override'),
9233            secret_store_id=d.get('secret_store_id'),
9234            tags=d.get('tags'),
9235            username=d.get('username'),
9236        )
class RabbitMQAMQP091:
9239class RabbitMQAMQP091:
9240    __slots__ = [
9241        'bind_interface',
9242        'egress_filter',
9243        'healthy',
9244        'hostname',
9245        'id',
9246        'name',
9247        'password',
9248        'port',
9249        'port_override',
9250        'secret_store_id',
9251        'tags',
9252        'tls_required',
9253        'username',
9254    ]
9255
9256    def __init__(
9257        self,
9258        bind_interface=None,
9259        egress_filter=None,
9260        healthy=None,
9261        hostname=None,
9262        id=None,
9263        name=None,
9264        password=None,
9265        port=None,
9266        port_override=None,
9267        secret_store_id=None,
9268        tags=None,
9269        tls_required=None,
9270        username=None,
9271    ):
9272        self.bind_interface = bind_interface if bind_interface is not None else ''
9273        '''
9274         Bind interface
9275        '''
9276        self.egress_filter = egress_filter if egress_filter is not None else ''
9277        '''
9278         A filter applied to the routing logic to pin datasource to nodes.
9279        '''
9280        self.healthy = healthy if healthy is not None else False
9281        '''
9282         True if the datasource is reachable and the credentials are valid.
9283        '''
9284        self.hostname = hostname if hostname is not None else ''
9285        self.id = id if id is not None else ''
9286        '''
9287         Unique identifier of the Resource.
9288        '''
9289        self.name = name if name is not None else ''
9290        '''
9291         Unique human-readable name of the Resource.
9292        '''
9293        self.password = password if password is not None else ''
9294        self.port = port if port is not None else 0
9295        self.port_override = port_override if port_override is not None else 0
9296        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9297        '''
9298         ID of the secret store containing credentials for this resource, if any.
9299        '''
9300        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9301        '''
9302         Tags is a map of key, value pairs.
9303        '''
9304        self.tls_required = tls_required if tls_required is not None else False
9305        self.username = username if username is not None else ''
9306
9307    def __repr__(self):
9308        return '<sdm.RabbitMQAMQP091 ' + \
9309            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9310            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9311            'healthy: ' + repr(self.healthy) + ' ' +\
9312            'hostname: ' + repr(self.hostname) + ' ' +\
9313            'id: ' + repr(self.id) + ' ' +\
9314            'name: ' + repr(self.name) + ' ' +\
9315            'password: ' + repr(self.password) + ' ' +\
9316            'port: ' + repr(self.port) + ' ' +\
9317            'port_override: ' + repr(self.port_override) + ' ' +\
9318            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9319            'tags: ' + repr(self.tags) + ' ' +\
9320            'tls_required: ' + repr(self.tls_required) + ' ' +\
9321            'username: ' + repr(self.username) + ' ' +\
9322            '>'
9323
9324    def to_dict(self):
9325        return {
9326            'bind_interface': self.bind_interface,
9327            'egress_filter': self.egress_filter,
9328            'healthy': self.healthy,
9329            'hostname': self.hostname,
9330            'id': self.id,
9331            'name': self.name,
9332            'password': self.password,
9333            'port': self.port,
9334            'port_override': self.port_override,
9335            'secret_store_id': self.secret_store_id,
9336            'tags': self.tags,
9337            'tls_required': self.tls_required,
9338            'username': self.username,
9339        }
9340
9341    @classmethod
9342    def from_dict(cls, d):
9343        return cls(
9344            bind_interface=d.get('bind_interface'),
9345            egress_filter=d.get('egress_filter'),
9346            healthy=d.get('healthy'),
9347            hostname=d.get('hostname'),
9348            id=d.get('id'),
9349            name=d.get('name'),
9350            password=d.get('password'),
9351            port=d.get('port'),
9352            port_override=d.get('port_override'),
9353            secret_store_id=d.get('secret_store_id'),
9354            tags=d.get('tags'),
9355            tls_required=d.get('tls_required'),
9356            username=d.get('username'),
9357        )
RabbitMQAMQP091( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
9256    def __init__(
9257        self,
9258        bind_interface=None,
9259        egress_filter=None,
9260        healthy=None,
9261        hostname=None,
9262        id=None,
9263        name=None,
9264        password=None,
9265        port=None,
9266        port_override=None,
9267        secret_store_id=None,
9268        tags=None,
9269        tls_required=None,
9270        username=None,
9271    ):
9272        self.bind_interface = bind_interface if bind_interface is not None else ''
9273        '''
9274         Bind interface
9275        '''
9276        self.egress_filter = egress_filter if egress_filter is not None else ''
9277        '''
9278         A filter applied to the routing logic to pin datasource to nodes.
9279        '''
9280        self.healthy = healthy if healthy is not None else False
9281        '''
9282         True if the datasource is reachable and the credentials are valid.
9283        '''
9284        self.hostname = hostname if hostname is not None else ''
9285        self.id = id if id is not None else ''
9286        '''
9287         Unique identifier of the Resource.
9288        '''
9289        self.name = name if name is not None else ''
9290        '''
9291         Unique human-readable name of the Resource.
9292        '''
9293        self.password = password if password is not None else ''
9294        self.port = port if port is not None else 0
9295        self.port_override = port_override if port_override is not None else 0
9296        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9297        '''
9298         ID of the secret store containing credentials for this resource, if any.
9299        '''
9300        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9301        '''
9302         Tags is a map of key, value pairs.
9303        '''
9304        self.tls_required = tls_required if tls_required is not None else False
9305        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
9324    def to_dict(self):
9325        return {
9326            'bind_interface': self.bind_interface,
9327            'egress_filter': self.egress_filter,
9328            'healthy': self.healthy,
9329            'hostname': self.hostname,
9330            'id': self.id,
9331            'name': self.name,
9332            'password': self.password,
9333            'port': self.port,
9334            'port_override': self.port_override,
9335            'secret_store_id': self.secret_store_id,
9336            'tags': self.tags,
9337            'tls_required': self.tls_required,
9338            'username': self.username,
9339        }
@classmethod
def from_dict(cls, d)
9341    @classmethod
9342    def from_dict(cls, d):
9343        return cls(
9344            bind_interface=d.get('bind_interface'),
9345            egress_filter=d.get('egress_filter'),
9346            healthy=d.get('healthy'),
9347            hostname=d.get('hostname'),
9348            id=d.get('id'),
9349            name=d.get('name'),
9350            password=d.get('password'),
9351            port=d.get('port'),
9352            port_override=d.get('port_override'),
9353            secret_store_id=d.get('secret_store_id'),
9354            tags=d.get('tags'),
9355            tls_required=d.get('tls_required'),
9356            username=d.get('username'),
9357        )
class RateLimitMetadata:
9360class RateLimitMetadata:
9361    '''
9362         RateLimitMetadata contains information about remaining requests avaialable
9363     to the user over some timeframe.
9364    '''
9365    __slots__ = [
9366        'bucket',
9367        'limit',
9368        'remaining',
9369        'reset_at',
9370    ]
9371
9372    def __init__(
9373        self,
9374        bucket=None,
9375        limit=None,
9376        remaining=None,
9377        reset_at=None,
9378    ):
9379        self.bucket = bucket if bucket is not None else ''
9380        '''
9381         The bucket this user/token is associated with, which may be shared between
9382         multiple users/tokens.
9383        '''
9384        self.limit = limit if limit is not None else 0
9385        '''
9386         How many total requests the user/token is authorized to make before being
9387         rate limited.
9388        '''
9389        self.remaining = remaining if remaining is not None else 0
9390        '''
9391         How many remaining requests out of the limit are still avaialable.
9392        '''
9393        self.reset_at = reset_at if reset_at is not None else None
9394        '''
9395         The time when remaining will be reset to limit.
9396        '''
9397
9398    def __repr__(self):
9399        return '<sdm.RateLimitMetadata ' + \
9400            'bucket: ' + repr(self.bucket) + ' ' +\
9401            'limit: ' + repr(self.limit) + ' ' +\
9402            'remaining: ' + repr(self.remaining) + ' ' +\
9403            'reset_at: ' + repr(self.reset_at) + ' ' +\
9404            '>'
9405
9406    def to_dict(self):
9407        return {
9408            'bucket': self.bucket,
9409            'limit': self.limit,
9410            'remaining': self.remaining,
9411            'reset_at': self.reset_at,
9412        }
9413
9414    @classmethod
9415    def from_dict(cls, d):
9416        return cls(
9417            bucket=d.get('bucket'),
9418            limit=d.get('limit'),
9419            remaining=d.get('remaining'),
9420            reset_at=d.get('reset_at'),
9421        )

RateLimitMetadata contains information about remaining requests avaialable to the user over some timeframe.

RateLimitMetadata(bucket=None, limit=None, remaining=None, reset_at=None)
9372    def __init__(
9373        self,
9374        bucket=None,
9375        limit=None,
9376        remaining=None,
9377        reset_at=None,
9378    ):
9379        self.bucket = bucket if bucket is not None else ''
9380        '''
9381         The bucket this user/token is associated with, which may be shared between
9382         multiple users/tokens.
9383        '''
9384        self.limit = limit if limit is not None else 0
9385        '''
9386         How many total requests the user/token is authorized to make before being
9387         rate limited.
9388        '''
9389        self.remaining = remaining if remaining is not None else 0
9390        '''
9391         How many remaining requests out of the limit are still avaialable.
9392        '''
9393        self.reset_at = reset_at if reset_at is not None else None
9394        '''
9395         The time when remaining will be reset to limit.
9396        '''
bucket

The bucket this user/token is associated with, which may be shared between multiple users/tokens.

limit

How many total requests the user/token is authorized to make before being rate limited.

remaining

How many remaining requests out of the limit are still avaialable.

reset_at

The time when remaining will be reset to limit.

def to_dict(self)
9406    def to_dict(self):
9407        return {
9408            'bucket': self.bucket,
9409            'limit': self.limit,
9410            'remaining': self.remaining,
9411            'reset_at': self.reset_at,
9412        }
@classmethod
def from_dict(cls, d)
9414    @classmethod
9415    def from_dict(cls, d):
9416        return cls(
9417            bucket=d.get('bucket'),
9418            limit=d.get('limit'),
9419            remaining=d.get('remaining'),
9420            reset_at=d.get('reset_at'),
9421        )
class RawTCP:
9424class RawTCP:
9425    __slots__ = [
9426        'bind_interface',
9427        'egress_filter',
9428        'healthy',
9429        'hostname',
9430        'id',
9431        'name',
9432        'port',
9433        'port_override',
9434        'secret_store_id',
9435        'tags',
9436    ]
9437
9438    def __init__(
9439        self,
9440        bind_interface=None,
9441        egress_filter=None,
9442        healthy=None,
9443        hostname=None,
9444        id=None,
9445        name=None,
9446        port=None,
9447        port_override=None,
9448        secret_store_id=None,
9449        tags=None,
9450    ):
9451        self.bind_interface = bind_interface if bind_interface is not None else ''
9452        '''
9453         Bind interface
9454        '''
9455        self.egress_filter = egress_filter if egress_filter is not None else ''
9456        '''
9457         A filter applied to the routing logic to pin datasource to nodes.
9458        '''
9459        self.healthy = healthy if healthy is not None else False
9460        '''
9461         True if the datasource is reachable and the credentials are valid.
9462        '''
9463        self.hostname = hostname if hostname is not None else ''
9464        self.id = id if id is not None else ''
9465        '''
9466         Unique identifier of the Resource.
9467        '''
9468        self.name = name if name is not None else ''
9469        '''
9470         Unique human-readable name of the Resource.
9471        '''
9472        self.port = port if port is not None else 0
9473        self.port_override = port_override if port_override is not None else 0
9474        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9475        '''
9476         ID of the secret store containing credentials for this resource, if any.
9477        '''
9478        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9479        '''
9480         Tags is a map of key, value pairs.
9481        '''
9482
9483    def __repr__(self):
9484        return '<sdm.RawTCP ' + \
9485            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9486            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9487            'healthy: ' + repr(self.healthy) + ' ' +\
9488            'hostname: ' + repr(self.hostname) + ' ' +\
9489            'id: ' + repr(self.id) + ' ' +\
9490            'name: ' + repr(self.name) + ' ' +\
9491            'port: ' + repr(self.port) + ' ' +\
9492            'port_override: ' + repr(self.port_override) + ' ' +\
9493            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9494            'tags: ' + repr(self.tags) + ' ' +\
9495            '>'
9496
9497    def to_dict(self):
9498        return {
9499            'bind_interface': self.bind_interface,
9500            'egress_filter': self.egress_filter,
9501            'healthy': self.healthy,
9502            'hostname': self.hostname,
9503            'id': self.id,
9504            'name': self.name,
9505            'port': self.port,
9506            'port_override': self.port_override,
9507            'secret_store_id': self.secret_store_id,
9508            'tags': self.tags,
9509        }
9510
9511    @classmethod
9512    def from_dict(cls, d):
9513        return cls(
9514            bind_interface=d.get('bind_interface'),
9515            egress_filter=d.get('egress_filter'),
9516            healthy=d.get('healthy'),
9517            hostname=d.get('hostname'),
9518            id=d.get('id'),
9519            name=d.get('name'),
9520            port=d.get('port'),
9521            port_override=d.get('port_override'),
9522            secret_store_id=d.get('secret_store_id'),
9523            tags=d.get('tags'),
9524        )
RawTCP( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
9438    def __init__(
9439        self,
9440        bind_interface=None,
9441        egress_filter=None,
9442        healthy=None,
9443        hostname=None,
9444        id=None,
9445        name=None,
9446        port=None,
9447        port_override=None,
9448        secret_store_id=None,
9449        tags=None,
9450    ):
9451        self.bind_interface = bind_interface if bind_interface is not None else ''
9452        '''
9453         Bind interface
9454        '''
9455        self.egress_filter = egress_filter if egress_filter is not None else ''
9456        '''
9457         A filter applied to the routing logic to pin datasource to nodes.
9458        '''
9459        self.healthy = healthy if healthy is not None else False
9460        '''
9461         True if the datasource is reachable and the credentials are valid.
9462        '''
9463        self.hostname = hostname if hostname is not None else ''
9464        self.id = id if id is not None else ''
9465        '''
9466         Unique identifier of the Resource.
9467        '''
9468        self.name = name if name is not None else ''
9469        '''
9470         Unique human-readable name of the Resource.
9471        '''
9472        self.port = port if port is not None else 0
9473        self.port_override = port_override if port_override is not None else 0
9474        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9475        '''
9476         ID of the secret store containing credentials for this resource, if any.
9477        '''
9478        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9479        '''
9480         Tags is a map of key, value pairs.
9481        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
9497    def to_dict(self):
9498        return {
9499            'bind_interface': self.bind_interface,
9500            'egress_filter': self.egress_filter,
9501            'healthy': self.healthy,
9502            'hostname': self.hostname,
9503            'id': self.id,
9504            'name': self.name,
9505            'port': self.port,
9506            'port_override': self.port_override,
9507            'secret_store_id': self.secret_store_id,
9508            'tags': self.tags,
9509        }
@classmethod
def from_dict(cls, d)
9511    @classmethod
9512    def from_dict(cls, d):
9513        return cls(
9514            bind_interface=d.get('bind_interface'),
9515            egress_filter=d.get('egress_filter'),
9516            healthy=d.get('healthy'),
9517            hostname=d.get('hostname'),
9518            id=d.get('id'),
9519            name=d.get('name'),
9520            port=d.get('port'),
9521            port_override=d.get('port_override'),
9522            secret_store_id=d.get('secret_store_id'),
9523            tags=d.get('tags'),
9524        )
class Redis:
9527class Redis:
9528    __slots__ = [
9529        'bind_interface',
9530        'egress_filter',
9531        'healthy',
9532        'hostname',
9533        'id',
9534        'name',
9535        'password',
9536        'port',
9537        'port_override',
9538        'secret_store_id',
9539        'tags',
9540        'tls_required',
9541        'username',
9542    ]
9543
9544    def __init__(
9545        self,
9546        bind_interface=None,
9547        egress_filter=None,
9548        healthy=None,
9549        hostname=None,
9550        id=None,
9551        name=None,
9552        password=None,
9553        port=None,
9554        port_override=None,
9555        secret_store_id=None,
9556        tags=None,
9557        tls_required=None,
9558        username=None,
9559    ):
9560        self.bind_interface = bind_interface if bind_interface is not None else ''
9561        '''
9562         Bind interface
9563        '''
9564        self.egress_filter = egress_filter if egress_filter is not None else ''
9565        '''
9566         A filter applied to the routing logic to pin datasource to nodes.
9567        '''
9568        self.healthy = healthy if healthy is not None else False
9569        '''
9570         True if the datasource is reachable and the credentials are valid.
9571        '''
9572        self.hostname = hostname if hostname is not None else ''
9573        self.id = id if id is not None else ''
9574        '''
9575         Unique identifier of the Resource.
9576        '''
9577        self.name = name if name is not None else ''
9578        '''
9579         Unique human-readable name of the Resource.
9580        '''
9581        self.password = password if password is not None else ''
9582        self.port = port if port is not None else 0
9583        self.port_override = port_override if port_override is not None else 0
9584        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9585        '''
9586         ID of the secret store containing credentials for this resource, if any.
9587        '''
9588        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9589        '''
9590         Tags is a map of key, value pairs.
9591        '''
9592        self.tls_required = tls_required if tls_required is not None else False
9593        self.username = username if username is not None else ''
9594
9595    def __repr__(self):
9596        return '<sdm.Redis ' + \
9597            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9598            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9599            'healthy: ' + repr(self.healthy) + ' ' +\
9600            'hostname: ' + repr(self.hostname) + ' ' +\
9601            'id: ' + repr(self.id) + ' ' +\
9602            'name: ' + repr(self.name) + ' ' +\
9603            'password: ' + repr(self.password) + ' ' +\
9604            'port: ' + repr(self.port) + ' ' +\
9605            'port_override: ' + repr(self.port_override) + ' ' +\
9606            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9607            'tags: ' + repr(self.tags) + ' ' +\
9608            'tls_required: ' + repr(self.tls_required) + ' ' +\
9609            'username: ' + repr(self.username) + ' ' +\
9610            '>'
9611
9612    def to_dict(self):
9613        return {
9614            'bind_interface': self.bind_interface,
9615            'egress_filter': self.egress_filter,
9616            'healthy': self.healthy,
9617            'hostname': self.hostname,
9618            'id': self.id,
9619            'name': self.name,
9620            'password': self.password,
9621            'port': self.port,
9622            'port_override': self.port_override,
9623            'secret_store_id': self.secret_store_id,
9624            'tags': self.tags,
9625            'tls_required': self.tls_required,
9626            'username': self.username,
9627        }
9628
9629    @classmethod
9630    def from_dict(cls, d):
9631        return cls(
9632            bind_interface=d.get('bind_interface'),
9633            egress_filter=d.get('egress_filter'),
9634            healthy=d.get('healthy'),
9635            hostname=d.get('hostname'),
9636            id=d.get('id'),
9637            name=d.get('name'),
9638            password=d.get('password'),
9639            port=d.get('port'),
9640            port_override=d.get('port_override'),
9641            secret_store_id=d.get('secret_store_id'),
9642            tags=d.get('tags'),
9643            tls_required=d.get('tls_required'),
9644            username=d.get('username'),
9645        )
Redis( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
9544    def __init__(
9545        self,
9546        bind_interface=None,
9547        egress_filter=None,
9548        healthy=None,
9549        hostname=None,
9550        id=None,
9551        name=None,
9552        password=None,
9553        port=None,
9554        port_override=None,
9555        secret_store_id=None,
9556        tags=None,
9557        tls_required=None,
9558        username=None,
9559    ):
9560        self.bind_interface = bind_interface if bind_interface is not None else ''
9561        '''
9562         Bind interface
9563        '''
9564        self.egress_filter = egress_filter if egress_filter is not None else ''
9565        '''
9566         A filter applied to the routing logic to pin datasource to nodes.
9567        '''
9568        self.healthy = healthy if healthy is not None else False
9569        '''
9570         True if the datasource is reachable and the credentials are valid.
9571        '''
9572        self.hostname = hostname if hostname is not None else ''
9573        self.id = id if id is not None else ''
9574        '''
9575         Unique identifier of the Resource.
9576        '''
9577        self.name = name if name is not None else ''
9578        '''
9579         Unique human-readable name of the Resource.
9580        '''
9581        self.password = password if password is not None else ''
9582        self.port = port if port is not None else 0
9583        self.port_override = port_override if port_override is not None else 0
9584        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9585        '''
9586         ID of the secret store containing credentials for this resource, if any.
9587        '''
9588        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9589        '''
9590         Tags is a map of key, value pairs.
9591        '''
9592        self.tls_required = tls_required if tls_required is not None else False
9593        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
9612    def to_dict(self):
9613        return {
9614            'bind_interface': self.bind_interface,
9615            'egress_filter': self.egress_filter,
9616            'healthy': self.healthy,
9617            'hostname': self.hostname,
9618            'id': self.id,
9619            'name': self.name,
9620            'password': self.password,
9621            'port': self.port,
9622            'port_override': self.port_override,
9623            'secret_store_id': self.secret_store_id,
9624            'tags': self.tags,
9625            'tls_required': self.tls_required,
9626            'username': self.username,
9627        }
@classmethod
def from_dict(cls, d)
9629    @classmethod
9630    def from_dict(cls, d):
9631        return cls(
9632            bind_interface=d.get('bind_interface'),
9633            egress_filter=d.get('egress_filter'),
9634            healthy=d.get('healthy'),
9635            hostname=d.get('hostname'),
9636            id=d.get('id'),
9637            name=d.get('name'),
9638            password=d.get('password'),
9639            port=d.get('port'),
9640            port_override=d.get('port_override'),
9641            secret_store_id=d.get('secret_store_id'),
9642            tags=d.get('tags'),
9643            tls_required=d.get('tls_required'),
9644            username=d.get('username'),
9645        )
class Redshift:
9648class Redshift:
9649    __slots__ = [
9650        'bind_interface',
9651        'database',
9652        'egress_filter',
9653        'healthy',
9654        'hostname',
9655        'id',
9656        'name',
9657        'override_database',
9658        'password',
9659        'port',
9660        'port_override',
9661        'secret_store_id',
9662        'tags',
9663        'username',
9664    ]
9665
9666    def __init__(
9667        self,
9668        bind_interface=None,
9669        database=None,
9670        egress_filter=None,
9671        healthy=None,
9672        hostname=None,
9673        id=None,
9674        name=None,
9675        override_database=None,
9676        password=None,
9677        port=None,
9678        port_override=None,
9679        secret_store_id=None,
9680        tags=None,
9681        username=None,
9682    ):
9683        self.bind_interface = bind_interface if bind_interface is not None else ''
9684        '''
9685         Bind interface
9686        '''
9687        self.database = database if database is not None else ''
9688        self.egress_filter = egress_filter if egress_filter is not None else ''
9689        '''
9690         A filter applied to the routing logic to pin datasource to nodes.
9691        '''
9692        self.healthy = healthy if healthy is not None else False
9693        '''
9694         True if the datasource is reachable and the credentials are valid.
9695        '''
9696        self.hostname = hostname if hostname is not None else ''
9697        self.id = id if id is not None else ''
9698        '''
9699         Unique identifier of the Resource.
9700        '''
9701        self.name = name if name is not None else ''
9702        '''
9703         Unique human-readable name of the Resource.
9704        '''
9705        self.override_database = override_database if override_database is not None else False
9706        self.password = password if password is not None else ''
9707        self.port = port if port is not None else 0
9708        self.port_override = port_override if port_override is not None else 0
9709        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9710        '''
9711         ID of the secret store containing credentials for this resource, if any.
9712        '''
9713        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9714        '''
9715         Tags is a map of key, value pairs.
9716        '''
9717        self.username = username if username is not None else ''
9718
9719    def __repr__(self):
9720        return '<sdm.Redshift ' + \
9721            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9722            'database: ' + repr(self.database) + ' ' +\
9723            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9724            'healthy: ' + repr(self.healthy) + ' ' +\
9725            'hostname: ' + repr(self.hostname) + ' ' +\
9726            'id: ' + repr(self.id) + ' ' +\
9727            'name: ' + repr(self.name) + ' ' +\
9728            'override_database: ' + repr(self.override_database) + ' ' +\
9729            'password: ' + repr(self.password) + ' ' +\
9730            'port: ' + repr(self.port) + ' ' +\
9731            'port_override: ' + repr(self.port_override) + ' ' +\
9732            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9733            'tags: ' + repr(self.tags) + ' ' +\
9734            'username: ' + repr(self.username) + ' ' +\
9735            '>'
9736
9737    def to_dict(self):
9738        return {
9739            'bind_interface': self.bind_interface,
9740            'database': self.database,
9741            'egress_filter': self.egress_filter,
9742            'healthy': self.healthy,
9743            'hostname': self.hostname,
9744            'id': self.id,
9745            'name': self.name,
9746            'override_database': self.override_database,
9747            'password': self.password,
9748            'port': self.port,
9749            'port_override': self.port_override,
9750            'secret_store_id': self.secret_store_id,
9751            'tags': self.tags,
9752            'username': self.username,
9753        }
9754
9755    @classmethod
9756    def from_dict(cls, d):
9757        return cls(
9758            bind_interface=d.get('bind_interface'),
9759            database=d.get('database'),
9760            egress_filter=d.get('egress_filter'),
9761            healthy=d.get('healthy'),
9762            hostname=d.get('hostname'),
9763            id=d.get('id'),
9764            name=d.get('name'),
9765            override_database=d.get('override_database'),
9766            password=d.get('password'),
9767            port=d.get('port'),
9768            port_override=d.get('port_override'),
9769            secret_store_id=d.get('secret_store_id'),
9770            tags=d.get('tags'),
9771            username=d.get('username'),
9772        )
Redshift( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
9666    def __init__(
9667        self,
9668        bind_interface=None,
9669        database=None,
9670        egress_filter=None,
9671        healthy=None,
9672        hostname=None,
9673        id=None,
9674        name=None,
9675        override_database=None,
9676        password=None,
9677        port=None,
9678        port_override=None,
9679        secret_store_id=None,
9680        tags=None,
9681        username=None,
9682    ):
9683        self.bind_interface = bind_interface if bind_interface is not None else ''
9684        '''
9685         Bind interface
9686        '''
9687        self.database = database if database is not None else ''
9688        self.egress_filter = egress_filter if egress_filter is not None else ''
9689        '''
9690         A filter applied to the routing logic to pin datasource to nodes.
9691        '''
9692        self.healthy = healthy if healthy is not None else False
9693        '''
9694         True if the datasource is reachable and the credentials are valid.
9695        '''
9696        self.hostname = hostname if hostname is not None else ''
9697        self.id = id if id is not None else ''
9698        '''
9699         Unique identifier of the Resource.
9700        '''
9701        self.name = name if name is not None else ''
9702        '''
9703         Unique human-readable name of the Resource.
9704        '''
9705        self.override_database = override_database if override_database is not None else False
9706        self.password = password if password is not None else ''
9707        self.port = port if port is not None else 0
9708        self.port_override = port_override if port_override is not None else 0
9709        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9710        '''
9711         ID of the secret store containing credentials for this resource, if any.
9712        '''
9713        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9714        '''
9715         Tags is a map of key, value pairs.
9716        '''
9717        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
9737    def to_dict(self):
9738        return {
9739            'bind_interface': self.bind_interface,
9740            'database': self.database,
9741            'egress_filter': self.egress_filter,
9742            'healthy': self.healthy,
9743            'hostname': self.hostname,
9744            'id': self.id,
9745            'name': self.name,
9746            'override_database': self.override_database,
9747            'password': self.password,
9748            'port': self.port,
9749            'port_override': self.port_override,
9750            'secret_store_id': self.secret_store_id,
9751            'tags': self.tags,
9752            'username': self.username,
9753        }
@classmethod
def from_dict(cls, d)
9755    @classmethod
9756    def from_dict(cls, d):
9757        return cls(
9758            bind_interface=d.get('bind_interface'),
9759            database=d.get('database'),
9760            egress_filter=d.get('egress_filter'),
9761            healthy=d.get('healthy'),
9762            hostname=d.get('hostname'),
9763            id=d.get('id'),
9764            name=d.get('name'),
9765            override_database=d.get('override_database'),
9766            password=d.get('password'),
9767            port=d.get('port'),
9768            port_override=d.get('port_override'),
9769            secret_store_id=d.get('secret_store_id'),
9770            tags=d.get('tags'),
9771            username=d.get('username'),
9772        )
class Relay:
9775class Relay:
9776    '''
9777         Relay represents a StrongDM CLI installation running in relay mode.
9778    '''
9779    __slots__ = [
9780        'device',
9781        'gateway_filter',
9782        'id',
9783        'location',
9784        'name',
9785        'state',
9786        'tags',
9787        'version',
9788    ]
9789
9790    def __init__(
9791        self,
9792        device=None,
9793        gateway_filter=None,
9794        id=None,
9795        location=None,
9796        name=None,
9797        state=None,
9798        tags=None,
9799        version=None,
9800    ):
9801        self.device = device if device is not None else ''
9802        '''
9803         Device is a read only device name uploaded by the gateway process when 
9804         it comes online.
9805        '''
9806        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
9807        '''
9808         GatewayFilter can be used to restrict the peering between relays and
9809         gateways.
9810        '''
9811        self.id = id if id is not None else ''
9812        '''
9813         Unique identifier of the Relay.
9814        '''
9815        self.location = location if location is not None else ''
9816        '''
9817         Location is a read only network location uploaded by the gateway process
9818         when it comes online.
9819        '''
9820        self.name = name if name is not None else ''
9821        '''
9822         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
9823        '''
9824        self.state = state if state is not None else ''
9825        '''
9826         The current state of the relay. One of: "new", "verifying_restart",
9827         "awaiting_restart", "restarting", "started", "stopped", "dead",
9828         "unknown".
9829        '''
9830        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9831        '''
9832         Tags is a map of key, value pairs.
9833        '''
9834        self.version = version if version is not None else ''
9835        '''
9836         Version is a read only sdm binary version uploaded by the gateway process
9837         when it comes online.
9838        '''
9839
9840    def __repr__(self):
9841        return '<sdm.Relay ' + \
9842            'device: ' + repr(self.device) + ' ' +\
9843            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
9844            'id: ' + repr(self.id) + ' ' +\
9845            'location: ' + repr(self.location) + ' ' +\
9846            'name: ' + repr(self.name) + ' ' +\
9847            'state: ' + repr(self.state) + ' ' +\
9848            'tags: ' + repr(self.tags) + ' ' +\
9849            'version: ' + repr(self.version) + ' ' +\
9850            '>'
9851
9852    def to_dict(self):
9853        return {
9854            'device': self.device,
9855            'gateway_filter': self.gateway_filter,
9856            'id': self.id,
9857            'location': self.location,
9858            'name': self.name,
9859            'state': self.state,
9860            'tags': self.tags,
9861            'version': self.version,
9862        }
9863
9864    @classmethod
9865    def from_dict(cls, d):
9866        return cls(
9867            device=d.get('device'),
9868            gateway_filter=d.get('gateway_filter'),
9869            id=d.get('id'),
9870            location=d.get('location'),
9871            name=d.get('name'),
9872            state=d.get('state'),
9873            tags=d.get('tags'),
9874            version=d.get('version'),
9875        )

Relay represents a StrongDM CLI installation running in relay mode.

Relay( device=None, gateway_filter=None, id=None, location=None, name=None, state=None, tags=None, version=None)
9790    def __init__(
9791        self,
9792        device=None,
9793        gateway_filter=None,
9794        id=None,
9795        location=None,
9796        name=None,
9797        state=None,
9798        tags=None,
9799        version=None,
9800    ):
9801        self.device = device if device is not None else ''
9802        '''
9803         Device is a read only device name uploaded by the gateway process when 
9804         it comes online.
9805        '''
9806        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
9807        '''
9808         GatewayFilter can be used to restrict the peering between relays and
9809         gateways.
9810        '''
9811        self.id = id if id is not None else ''
9812        '''
9813         Unique identifier of the Relay.
9814        '''
9815        self.location = location if location is not None else ''
9816        '''
9817         Location is a read only network location uploaded by the gateway process
9818         when it comes online.
9819        '''
9820        self.name = name if name is not None else ''
9821        '''
9822         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
9823        '''
9824        self.state = state if state is not None else ''
9825        '''
9826         The current state of the relay. One of: "new", "verifying_restart",
9827         "awaiting_restart", "restarting", "started", "stopped", "dead",
9828         "unknown".
9829        '''
9830        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9831        '''
9832         Tags is a map of key, value pairs.
9833        '''
9834        self.version = version if version is not None else ''
9835        '''
9836         Version is a read only sdm binary version uploaded by the gateway process
9837         when it comes online.
9838        '''
device

Device is a read only device name uploaded by the gateway process when it comes online.

gateway_filter

GatewayFilter can be used to restrict the peering between relays and gateways.

id

Unique identifier of the Relay.

location

Location is a read only network location uploaded by the gateway process when it comes online.

name

Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.

state

The current state of the relay. One of: "new", "verifying_restart", "awaiting_restart", "restarting", "started", "stopped", "dead", "unknown".

tags

Tags is a map of key, value pairs.

version

Version is a read only sdm binary version uploaded by the gateway process when it comes online.

def to_dict(self)
9852    def to_dict(self):
9853        return {
9854            'device': self.device,
9855            'gateway_filter': self.gateway_filter,
9856            'id': self.id,
9857            'location': self.location,
9858            'name': self.name,
9859            'state': self.state,
9860            'tags': self.tags,
9861            'version': self.version,
9862        }
@classmethod
def from_dict(cls, d)
9864    @classmethod
9865    def from_dict(cls, d):
9866        return cls(
9867            device=d.get('device'),
9868            gateway_filter=d.get('gateway_filter'),
9869            id=d.get('id'),
9870            location=d.get('location'),
9871            name=d.get('name'),
9872            state=d.get('state'),
9873            tags=d.get('tags'),
9874            version=d.get('version'),
9875        )
class RemoteIdentity:
9878class RemoteIdentity:
9879    '''
9880         RemoteIdentities define the username to be used for a specific account
9881     when connecting to a remote resource using that group.
9882    '''
9883    __slots__ = [
9884        'account_id',
9885        'id',
9886        'remote_identity_group_id',
9887        'username',
9888    ]
9889
9890    def __init__(
9891        self,
9892        account_id=None,
9893        id=None,
9894        remote_identity_group_id=None,
9895        username=None,
9896    ):
9897        self.account_id = account_id if account_id is not None else ''
9898        '''
9899         The account for this remote identity.
9900        '''
9901        self.id = id if id is not None else ''
9902        '''
9903         Unique identifier of the RemoteIdentity.
9904        '''
9905        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
9906        '''
9907         The remote identity group.
9908        '''
9909        self.username = username if username is not None else ''
9910        '''
9911         The username to be used as the remote identity for this account.
9912        '''
9913
9914    def __repr__(self):
9915        return '<sdm.RemoteIdentity ' + \
9916            'account_id: ' + repr(self.account_id) + ' ' +\
9917            'id: ' + repr(self.id) + ' ' +\
9918            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
9919            'username: ' + repr(self.username) + ' ' +\
9920            '>'
9921
9922    def to_dict(self):
9923        return {
9924            'account_id': self.account_id,
9925            'id': self.id,
9926            'remote_identity_group_id': self.remote_identity_group_id,
9927            'username': self.username,
9928        }
9929
9930    @classmethod
9931    def from_dict(cls, d):
9932        return cls(
9933            account_id=d.get('account_id'),
9934            id=d.get('id'),
9935            remote_identity_group_id=d.get('remote_identity_group_id'),
9936            username=d.get('username'),
9937        )

RemoteIdentities define the username to be used for a specific account when connecting to a remote resource using that group.

RemoteIdentity( account_id=None, id=None, remote_identity_group_id=None, username=None)
9890    def __init__(
9891        self,
9892        account_id=None,
9893        id=None,
9894        remote_identity_group_id=None,
9895        username=None,
9896    ):
9897        self.account_id = account_id if account_id is not None else ''
9898        '''
9899         The account for this remote identity.
9900        '''
9901        self.id = id if id is not None else ''
9902        '''
9903         Unique identifier of the RemoteIdentity.
9904        '''
9905        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
9906        '''
9907         The remote identity group.
9908        '''
9909        self.username = username if username is not None else ''
9910        '''
9911         The username to be used as the remote identity for this account.
9912        '''
account_id

The account for this remote identity.

id

Unique identifier of the RemoteIdentity.

remote_identity_group_id

The remote identity group.

username

The username to be used as the remote identity for this account.

def to_dict(self)
9922    def to_dict(self):
9923        return {
9924            'account_id': self.account_id,
9925            'id': self.id,
9926            'remote_identity_group_id': self.remote_identity_group_id,
9927            'username': self.username,
9928        }
@classmethod
def from_dict(cls, d)
9930    @classmethod
9931    def from_dict(cls, d):
9932        return cls(
9933            account_id=d.get('account_id'),
9934            id=d.get('id'),
9935            remote_identity_group_id=d.get('remote_identity_group_id'),
9936            username=d.get('username'),
9937        )
class RemoteIdentityCreateResponse:
9940class RemoteIdentityCreateResponse:
9941    '''
9942         RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.
9943    '''
9944    __slots__ = [
9945        'meta',
9946        'rate_limit',
9947        'remote_identity',
9948    ]
9949
9950    def __init__(
9951        self,
9952        meta=None,
9953        rate_limit=None,
9954        remote_identity=None,
9955    ):
9956        self.meta = meta if meta is not None else None
9957        '''
9958         Reserved for future use.
9959        '''
9960        self.rate_limit = rate_limit if rate_limit is not None else None
9961        '''
9962         Rate limit information.
9963        '''
9964        self.remote_identity = remote_identity if remote_identity is not None else None
9965        '''
9966         The created RemoteIdentity.
9967        '''
9968
9969    def __repr__(self):
9970        return '<sdm.RemoteIdentityCreateResponse ' + \
9971            'meta: ' + repr(self.meta) + ' ' +\
9972            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9973            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
9974            '>'
9975
9976    def to_dict(self):
9977        return {
9978            'meta': self.meta,
9979            'rate_limit': self.rate_limit,
9980            'remote_identity': self.remote_identity,
9981        }
9982
9983    @classmethod
9984    def from_dict(cls, d):
9985        return cls(
9986            meta=d.get('meta'),
9987            rate_limit=d.get('rate_limit'),
9988            remote_identity=d.get('remote_identity'),
9989        )

RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.

RemoteIdentityCreateResponse(meta=None, rate_limit=None, remote_identity=None)
9950    def __init__(
9951        self,
9952        meta=None,
9953        rate_limit=None,
9954        remote_identity=None,
9955    ):
9956        self.meta = meta if meta is not None else None
9957        '''
9958         Reserved for future use.
9959        '''
9960        self.rate_limit = rate_limit if rate_limit is not None else None
9961        '''
9962         Rate limit information.
9963        '''
9964        self.remote_identity = remote_identity if remote_identity is not None else None
9965        '''
9966         The created RemoteIdentity.
9967        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The created RemoteIdentity.

def to_dict(self)
9976    def to_dict(self):
9977        return {
9978            'meta': self.meta,
9979            'rate_limit': self.rate_limit,
9980            'remote_identity': self.remote_identity,
9981        }
@classmethod
def from_dict(cls, d)
9983    @classmethod
9984    def from_dict(cls, d):
9985        return cls(
9986            meta=d.get('meta'),
9987            rate_limit=d.get('rate_limit'),
9988            remote_identity=d.get('remote_identity'),
9989        )
class RemoteIdentityDeleteResponse:
 9992class RemoteIdentityDeleteResponse:
 9993    '''
 9994         RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.
 9995    '''
 9996    __slots__ = [
 9997        'meta',
 9998        'rate_limit',
 9999    ]
10000
10001    def __init__(
10002        self,
10003        meta=None,
10004        rate_limit=None,
10005    ):
10006        self.meta = meta if meta is not None else None
10007        '''
10008         Reserved for future use.
10009        '''
10010        self.rate_limit = rate_limit if rate_limit is not None else None
10011        '''
10012         Rate limit information.
10013        '''
10014
10015    def __repr__(self):
10016        return '<sdm.RemoteIdentityDeleteResponse ' + \
10017            'meta: ' + repr(self.meta) + ' ' +\
10018            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10019            '>'
10020
10021    def to_dict(self):
10022        return {
10023            'meta': self.meta,
10024            'rate_limit': self.rate_limit,
10025        }
10026
10027    @classmethod
10028    def from_dict(cls, d):
10029        return cls(
10030            meta=d.get('meta'),
10031            rate_limit=d.get('rate_limit'),
10032        )

RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.

RemoteIdentityDeleteResponse(meta=None, rate_limit=None)
10001    def __init__(
10002        self,
10003        meta=None,
10004        rate_limit=None,
10005    ):
10006        self.meta = meta if meta is not None else None
10007        '''
10008         Reserved for future use.
10009        '''
10010        self.rate_limit = rate_limit if rate_limit is not None else None
10011        '''
10012         Rate limit information.
10013        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
10021    def to_dict(self):
10022        return {
10023            'meta': self.meta,
10024            'rate_limit': self.rate_limit,
10025        }
@classmethod
def from_dict(cls, d)
10027    @classmethod
10028    def from_dict(cls, d):
10029        return cls(
10030            meta=d.get('meta'),
10031            rate_limit=d.get('rate_limit'),
10032        )
class RemoteIdentityGetResponse:
10035class RemoteIdentityGetResponse:
10036    '''
10037         RemoteIdentityGetResponse returns a requested RemoteIdentity.
10038    '''
10039    __slots__ = [
10040        'meta',
10041        'rate_limit',
10042        'remote_identity',
10043    ]
10044
10045    def __init__(
10046        self,
10047        meta=None,
10048        rate_limit=None,
10049        remote_identity=None,
10050    ):
10051        self.meta = meta if meta is not None else None
10052        '''
10053         Reserved for future use.
10054        '''
10055        self.rate_limit = rate_limit if rate_limit is not None else None
10056        '''
10057         Rate limit information.
10058        '''
10059        self.remote_identity = remote_identity if remote_identity is not None else None
10060        '''
10061         The requested RemoteIdentity.
10062        '''
10063
10064    def __repr__(self):
10065        return '<sdm.RemoteIdentityGetResponse ' + \
10066            'meta: ' + repr(self.meta) + ' ' +\
10067            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10068            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10069            '>'
10070
10071    def to_dict(self):
10072        return {
10073            'meta': self.meta,
10074            'rate_limit': self.rate_limit,
10075            'remote_identity': self.remote_identity,
10076        }
10077
10078    @classmethod
10079    def from_dict(cls, d):
10080        return cls(
10081            meta=d.get('meta'),
10082            rate_limit=d.get('rate_limit'),
10083            remote_identity=d.get('remote_identity'),
10084        )

RemoteIdentityGetResponse returns a requested RemoteIdentity.

RemoteIdentityGetResponse(meta=None, rate_limit=None, remote_identity=None)
10045    def __init__(
10046        self,
10047        meta=None,
10048        rate_limit=None,
10049        remote_identity=None,
10050    ):
10051        self.meta = meta if meta is not None else None
10052        '''
10053         Reserved for future use.
10054        '''
10055        self.rate_limit = rate_limit if rate_limit is not None else None
10056        '''
10057         Rate limit information.
10058        '''
10059        self.remote_identity = remote_identity if remote_identity is not None else None
10060        '''
10061         The requested RemoteIdentity.
10062        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The requested RemoteIdentity.

def to_dict(self)
10071    def to_dict(self):
10072        return {
10073            'meta': self.meta,
10074            'rate_limit': self.rate_limit,
10075            'remote_identity': self.remote_identity,
10076        }
@classmethod
def from_dict(cls, d)
10078    @classmethod
10079    def from_dict(cls, d):
10080        return cls(
10081            meta=d.get('meta'),
10082            rate_limit=d.get('rate_limit'),
10083            remote_identity=d.get('remote_identity'),
10084        )
class RemoteIdentityGroup:
10087class RemoteIdentityGroup:
10088    '''
10089         A RemoteIdentityGroup defines a group of remote identities.
10090    '''
10091    __slots__ = [
10092        'id',
10093        'name',
10094    ]
10095
10096    def __init__(
10097        self,
10098        id=None,
10099        name=None,
10100    ):
10101        self.id = id if id is not None else ''
10102        '''
10103         Unique identifier of the RemoteIdentityGroup.
10104        '''
10105        self.name = name if name is not None else ''
10106        '''
10107         Unique human-readable name of the RemoteIdentityGroup.
10108        '''
10109
10110    def __repr__(self):
10111        return '<sdm.RemoteIdentityGroup ' + \
10112            'id: ' + repr(self.id) + ' ' +\
10113            'name: ' + repr(self.name) + ' ' +\
10114            '>'
10115
10116    def to_dict(self):
10117        return {
10118            'id': self.id,
10119            'name': self.name,
10120        }
10121
10122    @classmethod
10123    def from_dict(cls, d):
10124        return cls(
10125            id=d.get('id'),
10126            name=d.get('name'),
10127        )

A RemoteIdentityGroup defines a group of remote identities.

RemoteIdentityGroup(id=None, name=None)
10096    def __init__(
10097        self,
10098        id=None,
10099        name=None,
10100    ):
10101        self.id = id if id is not None else ''
10102        '''
10103         Unique identifier of the RemoteIdentityGroup.
10104        '''
10105        self.name = name if name is not None else ''
10106        '''
10107         Unique human-readable name of the RemoteIdentityGroup.
10108        '''
id

Unique identifier of the RemoteIdentityGroup.

name

Unique human-readable name of the RemoteIdentityGroup.

def to_dict(self)
10116    def to_dict(self):
10117        return {
10118            'id': self.id,
10119            'name': self.name,
10120        }
@classmethod
def from_dict(cls, d)
10122    @classmethod
10123    def from_dict(cls, d):
10124        return cls(
10125            id=d.get('id'),
10126            name=d.get('name'),
10127        )
class RemoteIdentityGroupGetResponse:
10130class RemoteIdentityGroupGetResponse:
10131    '''
10132         RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.
10133    '''
10134    __slots__ = [
10135        'meta',
10136        'rate_limit',
10137        'remote_identity_group',
10138    ]
10139
10140    def __init__(
10141        self,
10142        meta=None,
10143        rate_limit=None,
10144        remote_identity_group=None,
10145    ):
10146        self.meta = meta if meta is not None else None
10147        '''
10148         Reserved for future use.
10149        '''
10150        self.rate_limit = rate_limit if rate_limit is not None else None
10151        '''
10152         Rate limit information.
10153        '''
10154        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10155        '''
10156         The requested RemoteIdentityGroup.
10157        '''
10158
10159    def __repr__(self):
10160        return '<sdm.RemoteIdentityGroupGetResponse ' + \
10161            'meta: ' + repr(self.meta) + ' ' +\
10162            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10163            'remote_identity_group: ' + repr(self.remote_identity_group) + ' ' +\
10164            '>'
10165
10166    def to_dict(self):
10167        return {
10168            'meta': self.meta,
10169            'rate_limit': self.rate_limit,
10170            'remote_identity_group': self.remote_identity_group,
10171        }
10172
10173    @classmethod
10174    def from_dict(cls, d):
10175        return cls(
10176            meta=d.get('meta'),
10177            rate_limit=d.get('rate_limit'),
10178            remote_identity_group=d.get('remote_identity_group'),
10179        )

RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.

RemoteIdentityGroupGetResponse(meta=None, rate_limit=None, remote_identity_group=None)
10140    def __init__(
10141        self,
10142        meta=None,
10143        rate_limit=None,
10144        remote_identity_group=None,
10145    ):
10146        self.meta = meta if meta is not None else None
10147        '''
10148         Reserved for future use.
10149        '''
10150        self.rate_limit = rate_limit if rate_limit is not None else None
10151        '''
10152         Rate limit information.
10153        '''
10154        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10155        '''
10156         The requested RemoteIdentityGroup.
10157        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity_group

The requested RemoteIdentityGroup.

def to_dict(self)
10166    def to_dict(self):
10167        return {
10168            'meta': self.meta,
10169            'rate_limit': self.rate_limit,
10170            'remote_identity_group': self.remote_identity_group,
10171        }
@classmethod
def from_dict(cls, d)
10173    @classmethod
10174    def from_dict(cls, d):
10175        return cls(
10176            meta=d.get('meta'),
10177            rate_limit=d.get('rate_limit'),
10178            remote_identity_group=d.get('remote_identity_group'),
10179        )
class RemoteIdentityUpdateResponse:
10182class RemoteIdentityUpdateResponse:
10183    '''
10184         RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by
10185     a RemoteIdentityUpdateRequest.
10186    '''
10187    __slots__ = [
10188        'meta',
10189        'rate_limit',
10190        'remote_identity',
10191    ]
10192
10193    def __init__(
10194        self,
10195        meta=None,
10196        rate_limit=None,
10197        remote_identity=None,
10198    ):
10199        self.meta = meta if meta is not None else None
10200        '''
10201         Reserved for future use.
10202        '''
10203        self.rate_limit = rate_limit if rate_limit is not None else None
10204        '''
10205         Rate limit information.
10206        '''
10207        self.remote_identity = remote_identity if remote_identity is not None else None
10208        '''
10209         The updated RemoteIdentity.
10210        '''
10211
10212    def __repr__(self):
10213        return '<sdm.RemoteIdentityUpdateResponse ' + \
10214            'meta: ' + repr(self.meta) + ' ' +\
10215            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10216            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10217            '>'
10218
10219    def to_dict(self):
10220        return {
10221            'meta': self.meta,
10222            'rate_limit': self.rate_limit,
10223            'remote_identity': self.remote_identity,
10224        }
10225
10226    @classmethod
10227    def from_dict(cls, d):
10228        return cls(
10229            meta=d.get('meta'),
10230            rate_limit=d.get('rate_limit'),
10231            remote_identity=d.get('remote_identity'),
10232        )

RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by a RemoteIdentityUpdateRequest.

RemoteIdentityUpdateResponse(meta=None, rate_limit=None, remote_identity=None)
10193    def __init__(
10194        self,
10195        meta=None,
10196        rate_limit=None,
10197        remote_identity=None,
10198    ):
10199        self.meta = meta if meta is not None else None
10200        '''
10201         Reserved for future use.
10202        '''
10203        self.rate_limit = rate_limit if rate_limit is not None else None
10204        '''
10205         Rate limit information.
10206        '''
10207        self.remote_identity = remote_identity if remote_identity is not None else None
10208        '''
10209         The updated RemoteIdentity.
10210        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The updated RemoteIdentity.

def to_dict(self)
10219    def to_dict(self):
10220        return {
10221            'meta': self.meta,
10222            'rate_limit': self.rate_limit,
10223            'remote_identity': self.remote_identity,
10224        }
@classmethod
def from_dict(cls, d)
10226    @classmethod
10227    def from_dict(cls, d):
10228        return cls(
10229            meta=d.get('meta'),
10230            rate_limit=d.get('rate_limit'),
10231            remote_identity=d.get('remote_identity'),
10232        )
class ResourceCreateResponse:
10235class ResourceCreateResponse:
10236    '''
10237         ResourceCreateResponse reports how the Resources were created in the system.
10238    '''
10239    __slots__ = [
10240        'meta',
10241        'rate_limit',
10242        'resource',
10243    ]
10244
10245    def __init__(
10246        self,
10247        meta=None,
10248        rate_limit=None,
10249        resource=None,
10250    ):
10251        self.meta = meta if meta is not None else None
10252        '''
10253         Reserved for future use.
10254        '''
10255        self.rate_limit = rate_limit if rate_limit is not None else None
10256        '''
10257         Rate limit information.
10258        '''
10259        self.resource = resource if resource is not None else None
10260        '''
10261         The created Resource.
10262        '''
10263
10264    def __repr__(self):
10265        return '<sdm.ResourceCreateResponse ' + \
10266            'meta: ' + repr(self.meta) + ' ' +\
10267            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10268            'resource: ' + repr(self.resource) + ' ' +\
10269            '>'
10270
10271    def to_dict(self):
10272        return {
10273            'meta': self.meta,
10274            'rate_limit': self.rate_limit,
10275            'resource': self.resource,
10276        }
10277
10278    @classmethod
10279    def from_dict(cls, d):
10280        return cls(
10281            meta=d.get('meta'),
10282            rate_limit=d.get('rate_limit'),
10283            resource=d.get('resource'),
10284        )

ResourceCreateResponse reports how the Resources were created in the system.

ResourceCreateResponse(meta=None, rate_limit=None, resource=None)
10245    def __init__(
10246        self,
10247        meta=None,
10248        rate_limit=None,
10249        resource=None,
10250    ):
10251        self.meta = meta if meta is not None else None
10252        '''
10253         Reserved for future use.
10254        '''
10255        self.rate_limit = rate_limit if rate_limit is not None else None
10256        '''
10257         Rate limit information.
10258        '''
10259        self.resource = resource if resource is not None else None
10260        '''
10261         The created Resource.
10262        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The created Resource.

def to_dict(self)
10271    def to_dict(self):
10272        return {
10273            'meta': self.meta,
10274            'rate_limit': self.rate_limit,
10275            'resource': self.resource,
10276        }
@classmethod
def from_dict(cls, d)
10278    @classmethod
10279    def from_dict(cls, d):
10280        return cls(
10281            meta=d.get('meta'),
10282            rate_limit=d.get('rate_limit'),
10283            resource=d.get('resource'),
10284        )
class ResourceDeleteResponse:
10287class ResourceDeleteResponse:
10288    '''
10289         ResourceDeleteResponse returns information about a Resource that was deleted.
10290    '''
10291    __slots__ = [
10292        'meta',
10293        'rate_limit',
10294    ]
10295
10296    def __init__(
10297        self,
10298        meta=None,
10299        rate_limit=None,
10300    ):
10301        self.meta = meta if meta is not None else None
10302        '''
10303         Reserved for future use.
10304        '''
10305        self.rate_limit = rate_limit if rate_limit is not None else None
10306        '''
10307         Rate limit information.
10308        '''
10309
10310    def __repr__(self):
10311        return '<sdm.ResourceDeleteResponse ' + \
10312            'meta: ' + repr(self.meta) + ' ' +\
10313            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10314            '>'
10315
10316    def to_dict(self):
10317        return {
10318            'meta': self.meta,
10319            'rate_limit': self.rate_limit,
10320        }
10321
10322    @classmethod
10323    def from_dict(cls, d):
10324        return cls(
10325            meta=d.get('meta'),
10326            rate_limit=d.get('rate_limit'),
10327        )

ResourceDeleteResponse returns information about a Resource that was deleted.

ResourceDeleteResponse(meta=None, rate_limit=None)
10296    def __init__(
10297        self,
10298        meta=None,
10299        rate_limit=None,
10300    ):
10301        self.meta = meta if meta is not None else None
10302        '''
10303         Reserved for future use.
10304        '''
10305        self.rate_limit = rate_limit if rate_limit is not None else None
10306        '''
10307         Rate limit information.
10308        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
10316    def to_dict(self):
10317        return {
10318            'meta': self.meta,
10319            'rate_limit': self.rate_limit,
10320        }
@classmethod
def from_dict(cls, d)
10322    @classmethod
10323    def from_dict(cls, d):
10324        return cls(
10325            meta=d.get('meta'),
10326            rate_limit=d.get('rate_limit'),
10327        )
class ResourceGetResponse:
10330class ResourceGetResponse:
10331    '''
10332         ResourceGetResponse returns a requested Resource.
10333    '''
10334    __slots__ = [
10335        'meta',
10336        'rate_limit',
10337        'resource',
10338    ]
10339
10340    def __init__(
10341        self,
10342        meta=None,
10343        rate_limit=None,
10344        resource=None,
10345    ):
10346        self.meta = meta if meta is not None else None
10347        '''
10348         Reserved for future use.
10349        '''
10350        self.rate_limit = rate_limit if rate_limit is not None else None
10351        '''
10352         Rate limit information.
10353        '''
10354        self.resource = resource if resource is not None else None
10355        '''
10356         The requested Resource.
10357        '''
10358
10359    def __repr__(self):
10360        return '<sdm.ResourceGetResponse ' + \
10361            'meta: ' + repr(self.meta) + ' ' +\
10362            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10363            'resource: ' + repr(self.resource) + ' ' +\
10364            '>'
10365
10366    def to_dict(self):
10367        return {
10368            'meta': self.meta,
10369            'rate_limit': self.rate_limit,
10370            'resource': self.resource,
10371        }
10372
10373    @classmethod
10374    def from_dict(cls, d):
10375        return cls(
10376            meta=d.get('meta'),
10377            rate_limit=d.get('rate_limit'),
10378            resource=d.get('resource'),
10379        )

ResourceGetResponse returns a requested Resource.

ResourceGetResponse(meta=None, rate_limit=None, resource=None)
10340    def __init__(
10341        self,
10342        meta=None,
10343        rate_limit=None,
10344        resource=None,
10345    ):
10346        self.meta = meta if meta is not None else None
10347        '''
10348         Reserved for future use.
10349        '''
10350        self.rate_limit = rate_limit if rate_limit is not None else None
10351        '''
10352         Rate limit information.
10353        '''
10354        self.resource = resource if resource is not None else None
10355        '''
10356         The requested Resource.
10357        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The requested Resource.

def to_dict(self)
10366    def to_dict(self):
10367        return {
10368            'meta': self.meta,
10369            'rate_limit': self.rate_limit,
10370            'resource': self.resource,
10371        }
@classmethod
def from_dict(cls, d)
10373    @classmethod
10374    def from_dict(cls, d):
10375        return cls(
10376            meta=d.get('meta'),
10377            rate_limit=d.get('rate_limit'),
10378            resource=d.get('resource'),
10379        )
class ResourceUpdateResponse:
10382class ResourceUpdateResponse:
10383    '''
10384         ResourceUpdateResponse returns the fields of a Resource after it has been updated by
10385     a ResourceUpdateRequest.
10386    '''
10387    __slots__ = [
10388        'meta',
10389        'rate_limit',
10390        'resource',
10391    ]
10392
10393    def __init__(
10394        self,
10395        meta=None,
10396        rate_limit=None,
10397        resource=None,
10398    ):
10399        self.meta = meta if meta is not None else None
10400        '''
10401         Reserved for future use.
10402        '''
10403        self.rate_limit = rate_limit if rate_limit is not None else None
10404        '''
10405         Rate limit information.
10406        '''
10407        self.resource = resource if resource is not None else None
10408        '''
10409         The updated Resource.
10410        '''
10411
10412    def __repr__(self):
10413        return '<sdm.ResourceUpdateResponse ' + \
10414            'meta: ' + repr(self.meta) + ' ' +\
10415            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10416            'resource: ' + repr(self.resource) + ' ' +\
10417            '>'
10418
10419    def to_dict(self):
10420        return {
10421            'meta': self.meta,
10422            'rate_limit': self.rate_limit,
10423            'resource': self.resource,
10424        }
10425
10426    @classmethod
10427    def from_dict(cls, d):
10428        return cls(
10429            meta=d.get('meta'),
10430            rate_limit=d.get('rate_limit'),
10431            resource=d.get('resource'),
10432        )

ResourceUpdateResponse returns the fields of a Resource after it has been updated by a ResourceUpdateRequest.

ResourceUpdateResponse(meta=None, rate_limit=None, resource=None)
10393    def __init__(
10394        self,
10395        meta=None,
10396        rate_limit=None,
10397        resource=None,
10398    ):
10399        self.meta = meta if meta is not None else None
10400        '''
10401         Reserved for future use.
10402        '''
10403        self.rate_limit = rate_limit if rate_limit is not None else None
10404        '''
10405         Rate limit information.
10406        '''
10407        self.resource = resource if resource is not None else None
10408        '''
10409         The updated Resource.
10410        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The updated Resource.

def to_dict(self)
10419    def to_dict(self):
10420        return {
10421            'meta': self.meta,
10422            'rate_limit': self.rate_limit,
10423            'resource': self.resource,
10424        }
@classmethod
def from_dict(cls, d)
10426    @classmethod
10427    def from_dict(cls, d):
10428        return cls(
10429            meta=d.get('meta'),
10430            rate_limit=d.get('rate_limit'),
10431            resource=d.get('resource'),
10432        )
class Role:
10435class Role:
10436    '''
10437         A Role has a list of access rules which determine which Resources the members
10438     of the Role have access to. An Account can be a member of multiple Roles via
10439     AccountAttachments.
10440    '''
10441    __slots__ = [
10442        'access_rules',
10443        'id',
10444        'managed_by',
10445        'name',
10446        'tags',
10447    ]
10448
10449    def __init__(
10450        self,
10451        access_rules=None,
10452        id=None,
10453        managed_by=None,
10454        name=None,
10455        tags=None,
10456    ):
10457        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
10458        )
10459        '''
10460         AccessRules is a list of access rules defining the resources this Role has access to.
10461        '''
10462        self.id = id if id is not None else ''
10463        '''
10464         Unique identifier of the Role.
10465        '''
10466        self.managed_by = managed_by if managed_by is not None else ''
10467        '''
10468         Managed By is a read only field for what service manages this role, e.g. StrongDM, Okta, Azure.
10469        '''
10470        self.name = name if name is not None else ''
10471        '''
10472         Unique human-readable name of the Role.
10473        '''
10474        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10475        '''
10476         Tags is a map of key, value pairs.
10477        '''
10478
10479    def __repr__(self):
10480        return '<sdm.Role ' + \
10481            'access_rules: ' + repr(self.access_rules) + ' ' +\
10482            'id: ' + repr(self.id) + ' ' +\
10483            'managed_by: ' + repr(self.managed_by) + ' ' +\
10484            'name: ' + repr(self.name) + ' ' +\
10485            'tags: ' + repr(self.tags) + ' ' +\
10486            '>'
10487
10488    def to_dict(self):
10489        return {
10490            'access_rules': self.access_rules,
10491            'id': self.id,
10492            'managed_by': self.managed_by,
10493            'name': self.name,
10494            'tags': self.tags,
10495        }
10496
10497    @classmethod
10498    def from_dict(cls, d):
10499        return cls(
10500            access_rules=d.get('access_rules'),
10501            id=d.get('id'),
10502            managed_by=d.get('managed_by'),
10503            name=d.get('name'),
10504            tags=d.get('tags'),
10505        )

A Role has a list of access rules which determine which Resources the members of the Role have access to. An Account can be a member of multiple Roles via AccountAttachments.

Role(access_rules=None, id=None, managed_by=None, name=None, tags=None)
10449    def __init__(
10450        self,
10451        access_rules=None,
10452        id=None,
10453        managed_by=None,
10454        name=None,
10455        tags=None,
10456    ):
10457        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
10458        )
10459        '''
10460         AccessRules is a list of access rules defining the resources this Role has access to.
10461        '''
10462        self.id = id if id is not None else ''
10463        '''
10464         Unique identifier of the Role.
10465        '''
10466        self.managed_by = managed_by if managed_by is not None else ''
10467        '''
10468         Managed By is a read only field for what service manages this role, e.g. StrongDM, Okta, Azure.
10469        '''
10470        self.name = name if name is not None else ''
10471        '''
10472         Unique human-readable name of the Role.
10473        '''
10474        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10475        '''
10476         Tags is a map of key, value pairs.
10477        '''
access_rules

AccessRules is a list of access rules defining the resources this Role has access to.

id

Unique identifier of the Role.

managed_by

Managed By is a read only field for what service manages this role, e.g. StrongDM, Okta, Azure.

name

Unique human-readable name of the Role.

tags

Tags is a map of key, value pairs.

def to_dict(self)
10488    def to_dict(self):
10489        return {
10490            'access_rules': self.access_rules,
10491            'id': self.id,
10492            'managed_by': self.managed_by,
10493            'name': self.name,
10494            'tags': self.tags,
10495        }
@classmethod
def from_dict(cls, d)
10497    @classmethod
10498    def from_dict(cls, d):
10499        return cls(
10500            access_rules=d.get('access_rules'),
10501            id=d.get('id'),
10502            managed_by=d.get('managed_by'),
10503            name=d.get('name'),
10504            tags=d.get('tags'),
10505        )
class RoleCreateResponse:
10508class RoleCreateResponse:
10509    '''
10510         RoleCreateResponse reports how the Roles were created in the system. It can
10511     communicate partial successes or failures.
10512    '''
10513    __slots__ = [
10514        'meta',
10515        'rate_limit',
10516        'role',
10517    ]
10518
10519    def __init__(
10520        self,
10521        meta=None,
10522        rate_limit=None,
10523        role=None,
10524    ):
10525        self.meta = meta if meta is not None else None
10526        '''
10527         Reserved for future use.
10528        '''
10529        self.rate_limit = rate_limit if rate_limit is not None else None
10530        '''
10531         Rate limit information.
10532        '''
10533        self.role = role if role is not None else None
10534        '''
10535         The created Role.
10536        '''
10537
10538    def __repr__(self):
10539        return '<sdm.RoleCreateResponse ' + \
10540            'meta: ' + repr(self.meta) + ' ' +\
10541            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10542            'role: ' + repr(self.role) + ' ' +\
10543            '>'
10544
10545    def to_dict(self):
10546        return {
10547            'meta': self.meta,
10548            'rate_limit': self.rate_limit,
10549            'role': self.role,
10550        }
10551
10552    @classmethod
10553    def from_dict(cls, d):
10554        return cls(
10555            meta=d.get('meta'),
10556            rate_limit=d.get('rate_limit'),
10557            role=d.get('role'),
10558        )

RoleCreateResponse reports how the Roles were created in the system. It can communicate partial successes or failures.

RoleCreateResponse(meta=None, rate_limit=None, role=None)
10519    def __init__(
10520        self,
10521        meta=None,
10522        rate_limit=None,
10523        role=None,
10524    ):
10525        self.meta = meta if meta is not None else None
10526        '''
10527         Reserved for future use.
10528        '''
10529        self.rate_limit = rate_limit if rate_limit is not None else None
10530        '''
10531         Rate limit information.
10532        '''
10533        self.role = role if role is not None else None
10534        '''
10535         The created Role.
10536        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The created Role.

def to_dict(self)
10545    def to_dict(self):
10546        return {
10547            'meta': self.meta,
10548            'rate_limit': self.rate_limit,
10549            'role': self.role,
10550        }
@classmethod
def from_dict(cls, d)
10552    @classmethod
10553    def from_dict(cls, d):
10554        return cls(
10555            meta=d.get('meta'),
10556            rate_limit=d.get('rate_limit'),
10557            role=d.get('role'),
10558        )
class RoleDeleteResponse:
10561class RoleDeleteResponse:
10562    '''
10563         RoleDeleteResponse returns information about a Role that was deleted.
10564    '''
10565    __slots__ = [
10566        'meta',
10567        'rate_limit',
10568    ]
10569
10570    def __init__(
10571        self,
10572        meta=None,
10573        rate_limit=None,
10574    ):
10575        self.meta = meta if meta is not None else None
10576        '''
10577         Reserved for future use.
10578        '''
10579        self.rate_limit = rate_limit if rate_limit is not None else None
10580        '''
10581         Rate limit information.
10582        '''
10583
10584    def __repr__(self):
10585        return '<sdm.RoleDeleteResponse ' + \
10586            'meta: ' + repr(self.meta) + ' ' +\
10587            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10588            '>'
10589
10590    def to_dict(self):
10591        return {
10592            'meta': self.meta,
10593            'rate_limit': self.rate_limit,
10594        }
10595
10596    @classmethod
10597    def from_dict(cls, d):
10598        return cls(
10599            meta=d.get('meta'),
10600            rate_limit=d.get('rate_limit'),
10601        )

RoleDeleteResponse returns information about a Role that was deleted.

RoleDeleteResponse(meta=None, rate_limit=None)
10570    def __init__(
10571        self,
10572        meta=None,
10573        rate_limit=None,
10574    ):
10575        self.meta = meta if meta is not None else None
10576        '''
10577         Reserved for future use.
10578        '''
10579        self.rate_limit = rate_limit if rate_limit is not None else None
10580        '''
10581         Rate limit information.
10582        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
10590    def to_dict(self):
10591        return {
10592            'meta': self.meta,
10593            'rate_limit': self.rate_limit,
10594        }
@classmethod
def from_dict(cls, d)
10596    @classmethod
10597    def from_dict(cls, d):
10598        return cls(
10599            meta=d.get('meta'),
10600            rate_limit=d.get('rate_limit'),
10601        )
class RoleGetResponse:
10604class RoleGetResponse:
10605    '''
10606         RoleGetResponse returns a requested Role.
10607    '''
10608    __slots__ = [
10609        'meta',
10610        'rate_limit',
10611        'role',
10612    ]
10613
10614    def __init__(
10615        self,
10616        meta=None,
10617        rate_limit=None,
10618        role=None,
10619    ):
10620        self.meta = meta if meta is not None else None
10621        '''
10622         Reserved for future use.
10623        '''
10624        self.rate_limit = rate_limit if rate_limit is not None else None
10625        '''
10626         Rate limit information.
10627        '''
10628        self.role = role if role is not None else None
10629        '''
10630         The requested Role.
10631        '''
10632
10633    def __repr__(self):
10634        return '<sdm.RoleGetResponse ' + \
10635            'meta: ' + repr(self.meta) + ' ' +\
10636            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10637            'role: ' + repr(self.role) + ' ' +\
10638            '>'
10639
10640    def to_dict(self):
10641        return {
10642            'meta': self.meta,
10643            'rate_limit': self.rate_limit,
10644            'role': self.role,
10645        }
10646
10647    @classmethod
10648    def from_dict(cls, d):
10649        return cls(
10650            meta=d.get('meta'),
10651            rate_limit=d.get('rate_limit'),
10652            role=d.get('role'),
10653        )

RoleGetResponse returns a requested Role.

RoleGetResponse(meta=None, rate_limit=None, role=None)
10614    def __init__(
10615        self,
10616        meta=None,
10617        rate_limit=None,
10618        role=None,
10619    ):
10620        self.meta = meta if meta is not None else None
10621        '''
10622         Reserved for future use.
10623        '''
10624        self.rate_limit = rate_limit if rate_limit is not None else None
10625        '''
10626         Rate limit information.
10627        '''
10628        self.role = role if role is not None else None
10629        '''
10630         The requested Role.
10631        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The requested Role.

def to_dict(self)
10640    def to_dict(self):
10641        return {
10642            'meta': self.meta,
10643            'rate_limit': self.rate_limit,
10644            'role': self.role,
10645        }
@classmethod
def from_dict(cls, d)
10647    @classmethod
10648    def from_dict(cls, d):
10649        return cls(
10650            meta=d.get('meta'),
10651            rate_limit=d.get('rate_limit'),
10652            role=d.get('role'),
10653        )
class RoleUpdateResponse:
10656class RoleUpdateResponse:
10657    '''
10658         RoleUpdateResponse returns the fields of a Role after it has been updated by
10659     a RoleUpdateRequest.
10660    '''
10661    __slots__ = [
10662        'meta',
10663        'rate_limit',
10664        'role',
10665    ]
10666
10667    def __init__(
10668        self,
10669        meta=None,
10670        rate_limit=None,
10671        role=None,
10672    ):
10673        self.meta = meta if meta is not None else None
10674        '''
10675         Reserved for future use.
10676        '''
10677        self.rate_limit = rate_limit if rate_limit is not None else None
10678        '''
10679         Rate limit information.
10680        '''
10681        self.role = role if role is not None else None
10682        '''
10683         The updated Role.
10684        '''
10685
10686    def __repr__(self):
10687        return '<sdm.RoleUpdateResponse ' + \
10688            'meta: ' + repr(self.meta) + ' ' +\
10689            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10690            'role: ' + repr(self.role) + ' ' +\
10691            '>'
10692
10693    def to_dict(self):
10694        return {
10695            'meta': self.meta,
10696            'rate_limit': self.rate_limit,
10697            'role': self.role,
10698        }
10699
10700    @classmethod
10701    def from_dict(cls, d):
10702        return cls(
10703            meta=d.get('meta'),
10704            rate_limit=d.get('rate_limit'),
10705            role=d.get('role'),
10706        )

RoleUpdateResponse returns the fields of a Role after it has been updated by a RoleUpdateRequest.

RoleUpdateResponse(meta=None, rate_limit=None, role=None)
10667    def __init__(
10668        self,
10669        meta=None,
10670        rate_limit=None,
10671        role=None,
10672    ):
10673        self.meta = meta if meta is not None else None
10674        '''
10675         Reserved for future use.
10676        '''
10677        self.rate_limit = rate_limit if rate_limit is not None else None
10678        '''
10679         Rate limit information.
10680        '''
10681        self.role = role if role is not None else None
10682        '''
10683         The updated Role.
10684        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The updated Role.

def to_dict(self)
10693    def to_dict(self):
10694        return {
10695            'meta': self.meta,
10696            'rate_limit': self.rate_limit,
10697            'role': self.role,
10698        }
@classmethod
def from_dict(cls, d)
10700    @classmethod
10701    def from_dict(cls, d):
10702        return cls(
10703            meta=d.get('meta'),
10704            rate_limit=d.get('rate_limit'),
10705            role=d.get('role'),
10706        )
class SQLServer:
10709class SQLServer:
10710    __slots__ = [
10711        'bind_interface',
10712        'database',
10713        'egress_filter',
10714        'healthy',
10715        'hostname',
10716        'id',
10717        'name',
10718        'override_database',
10719        'password',
10720        'port',
10721        'port_override',
10722        'schema',
10723        'secret_store_id',
10724        'tags',
10725        'username',
10726    ]
10727
10728    def __init__(
10729        self,
10730        bind_interface=None,
10731        database=None,
10732        egress_filter=None,
10733        healthy=None,
10734        hostname=None,
10735        id=None,
10736        name=None,
10737        override_database=None,
10738        password=None,
10739        port=None,
10740        port_override=None,
10741        schema=None,
10742        secret_store_id=None,
10743        tags=None,
10744        username=None,
10745    ):
10746        self.bind_interface = bind_interface if bind_interface is not None else ''
10747        '''
10748         Bind interface
10749        '''
10750        self.database = database if database is not None else ''
10751        self.egress_filter = egress_filter if egress_filter is not None else ''
10752        '''
10753         A filter applied to the routing logic to pin datasource to nodes.
10754        '''
10755        self.healthy = healthy if healthy is not None else False
10756        '''
10757         True if the datasource is reachable and the credentials are valid.
10758        '''
10759        self.hostname = hostname if hostname is not None else ''
10760        self.id = id if id is not None else ''
10761        '''
10762         Unique identifier of the Resource.
10763        '''
10764        self.name = name if name is not None else ''
10765        '''
10766         Unique human-readable name of the Resource.
10767        '''
10768        self.override_database = override_database if override_database is not None else False
10769        self.password = password if password is not None else ''
10770        self.port = port if port is not None else 0
10771        self.port_override = port_override if port_override is not None else 0
10772        self.schema = schema if schema is not None else ''
10773        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10774        '''
10775         ID of the secret store containing credentials for this resource, if any.
10776        '''
10777        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10778        '''
10779         Tags is a map of key, value pairs.
10780        '''
10781        self.username = username if username is not None else ''
10782
10783    def __repr__(self):
10784        return '<sdm.SQLServer ' + \
10785            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10786            'database: ' + repr(self.database) + ' ' +\
10787            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10788            'healthy: ' + repr(self.healthy) + ' ' +\
10789            'hostname: ' + repr(self.hostname) + ' ' +\
10790            'id: ' + repr(self.id) + ' ' +\
10791            'name: ' + repr(self.name) + ' ' +\
10792            'override_database: ' + repr(self.override_database) + ' ' +\
10793            'password: ' + repr(self.password) + ' ' +\
10794            'port: ' + repr(self.port) + ' ' +\
10795            'port_override: ' + repr(self.port_override) + ' ' +\
10796            'schema: ' + repr(self.schema) + ' ' +\
10797            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10798            'tags: ' + repr(self.tags) + ' ' +\
10799            'username: ' + repr(self.username) + ' ' +\
10800            '>'
10801
10802    def to_dict(self):
10803        return {
10804            'bind_interface': self.bind_interface,
10805            'database': self.database,
10806            'egress_filter': self.egress_filter,
10807            'healthy': self.healthy,
10808            'hostname': self.hostname,
10809            'id': self.id,
10810            'name': self.name,
10811            'override_database': self.override_database,
10812            'password': self.password,
10813            'port': self.port,
10814            'port_override': self.port_override,
10815            'schema': self.schema,
10816            'secret_store_id': self.secret_store_id,
10817            'tags': self.tags,
10818            'username': self.username,
10819        }
10820
10821    @classmethod
10822    def from_dict(cls, d):
10823        return cls(
10824            bind_interface=d.get('bind_interface'),
10825            database=d.get('database'),
10826            egress_filter=d.get('egress_filter'),
10827            healthy=d.get('healthy'),
10828            hostname=d.get('hostname'),
10829            id=d.get('id'),
10830            name=d.get('name'),
10831            override_database=d.get('override_database'),
10832            password=d.get('password'),
10833            port=d.get('port'),
10834            port_override=d.get('port_override'),
10835            schema=d.get('schema'),
10836            secret_store_id=d.get('secret_store_id'),
10837            tags=d.get('tags'),
10838            username=d.get('username'),
10839        )
SQLServer( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None)
10728    def __init__(
10729        self,
10730        bind_interface=None,
10731        database=None,
10732        egress_filter=None,
10733        healthy=None,
10734        hostname=None,
10735        id=None,
10736        name=None,
10737        override_database=None,
10738        password=None,
10739        port=None,
10740        port_override=None,
10741        schema=None,
10742        secret_store_id=None,
10743        tags=None,
10744        username=None,
10745    ):
10746        self.bind_interface = bind_interface if bind_interface is not None else ''
10747        '''
10748         Bind interface
10749        '''
10750        self.database = database if database is not None else ''
10751        self.egress_filter = egress_filter if egress_filter is not None else ''
10752        '''
10753         A filter applied to the routing logic to pin datasource to nodes.
10754        '''
10755        self.healthy = healthy if healthy is not None else False
10756        '''
10757         True if the datasource is reachable and the credentials are valid.
10758        '''
10759        self.hostname = hostname if hostname is not None else ''
10760        self.id = id if id is not None else ''
10761        '''
10762         Unique identifier of the Resource.
10763        '''
10764        self.name = name if name is not None else ''
10765        '''
10766         Unique human-readable name of the Resource.
10767        '''
10768        self.override_database = override_database if override_database is not None else False
10769        self.password = password if password is not None else ''
10770        self.port = port if port is not None else 0
10771        self.port_override = port_override if port_override is not None else 0
10772        self.schema = schema if schema is not None else ''
10773        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10774        '''
10775         ID of the secret store containing credentials for this resource, if any.
10776        '''
10777        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10778        '''
10779         Tags is a map of key, value pairs.
10780        '''
10781        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
schema
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10802    def to_dict(self):
10803        return {
10804            'bind_interface': self.bind_interface,
10805            'database': self.database,
10806            'egress_filter': self.egress_filter,
10807            'healthy': self.healthy,
10808            'hostname': self.hostname,
10809            'id': self.id,
10810            'name': self.name,
10811            'override_database': self.override_database,
10812            'password': self.password,
10813            'port': self.port,
10814            'port_override': self.port_override,
10815            'schema': self.schema,
10816            'secret_store_id': self.secret_store_id,
10817            'tags': self.tags,
10818            'username': self.username,
10819        }
@classmethod
def from_dict(cls, d)
10821    @classmethod
10822    def from_dict(cls, d):
10823        return cls(
10824            bind_interface=d.get('bind_interface'),
10825            database=d.get('database'),
10826            egress_filter=d.get('egress_filter'),
10827            healthy=d.get('healthy'),
10828            hostname=d.get('hostname'),
10829            id=d.get('id'),
10830            name=d.get('name'),
10831            override_database=d.get('override_database'),
10832            password=d.get('password'),
10833            port=d.get('port'),
10834            port_override=d.get('port_override'),
10835            schema=d.get('schema'),
10836            secret_store_id=d.get('secret_store_id'),
10837            tags=d.get('tags'),
10838            username=d.get('username'),
10839        )
class SSH:
10842class SSH:
10843    __slots__ = [
10844        'allow_deprecated_key_exchanges',
10845        'bind_interface',
10846        'egress_filter',
10847        'healthy',
10848        'hostname',
10849        'id',
10850        'key_type',
10851        'name',
10852        'port',
10853        'port_forwarding',
10854        'port_override',
10855        'public_key',
10856        'secret_store_id',
10857        'tags',
10858        'username',
10859    ]
10860
10861    def __init__(
10862        self,
10863        allow_deprecated_key_exchanges=None,
10864        bind_interface=None,
10865        egress_filter=None,
10866        healthy=None,
10867        hostname=None,
10868        id=None,
10869        key_type=None,
10870        name=None,
10871        port=None,
10872        port_forwarding=None,
10873        port_override=None,
10874        public_key=None,
10875        secret_store_id=None,
10876        tags=None,
10877        username=None,
10878    ):
10879        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10880        self.bind_interface = bind_interface if bind_interface is not None else ''
10881        '''
10882         Bind interface
10883        '''
10884        self.egress_filter = egress_filter if egress_filter is not None else ''
10885        '''
10886         A filter applied to the routing logic to pin datasource to nodes.
10887        '''
10888        self.healthy = healthy if healthy is not None else False
10889        '''
10890         True if the datasource is reachable and the credentials are valid.
10891        '''
10892        self.hostname = hostname if hostname is not None else ''
10893        self.id = id if id is not None else ''
10894        '''
10895         Unique identifier of the Resource.
10896        '''
10897        self.key_type = key_type if key_type is not None else ''
10898        self.name = name if name is not None else ''
10899        '''
10900         Unique human-readable name of the Resource.
10901        '''
10902        self.port = port if port is not None else 0
10903        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10904        self.port_override = port_override if port_override is not None else 0
10905        self.public_key = public_key if public_key is not None else ''
10906        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10907        '''
10908         ID of the secret store containing credentials for this resource, if any.
10909        '''
10910        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10911        '''
10912         Tags is a map of key, value pairs.
10913        '''
10914        self.username = username if username is not None else ''
10915
10916    def __repr__(self):
10917        return '<sdm.SSH ' + \
10918            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10919            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10920            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10921            'healthy: ' + repr(self.healthy) + ' ' +\
10922            'hostname: ' + repr(self.hostname) + ' ' +\
10923            'id: ' + repr(self.id) + ' ' +\
10924            'key_type: ' + repr(self.key_type) + ' ' +\
10925            'name: ' + repr(self.name) + ' ' +\
10926            'port: ' + repr(self.port) + ' ' +\
10927            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10928            'port_override: ' + repr(self.port_override) + ' ' +\
10929            'public_key: ' + repr(self.public_key) + ' ' +\
10930            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10931            'tags: ' + repr(self.tags) + ' ' +\
10932            'username: ' + repr(self.username) + ' ' +\
10933            '>'
10934
10935    def to_dict(self):
10936        return {
10937            'allow_deprecated_key_exchanges':
10938            self.allow_deprecated_key_exchanges,
10939            'bind_interface': self.bind_interface,
10940            'egress_filter': self.egress_filter,
10941            'healthy': self.healthy,
10942            'hostname': self.hostname,
10943            'id': self.id,
10944            'key_type': self.key_type,
10945            'name': self.name,
10946            'port': self.port,
10947            'port_forwarding': self.port_forwarding,
10948            'port_override': self.port_override,
10949            'public_key': self.public_key,
10950            'secret_store_id': self.secret_store_id,
10951            'tags': self.tags,
10952            'username': self.username,
10953        }
10954
10955    @classmethod
10956    def from_dict(cls, d):
10957        return cls(
10958            allow_deprecated_key_exchanges=d.get(
10959                'allow_deprecated_key_exchanges'),
10960            bind_interface=d.get('bind_interface'),
10961            egress_filter=d.get('egress_filter'),
10962            healthy=d.get('healthy'),
10963            hostname=d.get('hostname'),
10964            id=d.get('id'),
10965            key_type=d.get('key_type'),
10966            name=d.get('name'),
10967            port=d.get('port'),
10968            port_forwarding=d.get('port_forwarding'),
10969            port_override=d.get('port_override'),
10970            public_key=d.get('public_key'),
10971            secret_store_id=d.get('secret_store_id'),
10972            tags=d.get('tags'),
10973            username=d.get('username'),
10974        )
SSH( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, key_type=None, name=None, port=None, port_forwarding=None, port_override=None, public_key=None, secret_store_id=None, tags=None, username=None)
10861    def __init__(
10862        self,
10863        allow_deprecated_key_exchanges=None,
10864        bind_interface=None,
10865        egress_filter=None,
10866        healthy=None,
10867        hostname=None,
10868        id=None,
10869        key_type=None,
10870        name=None,
10871        port=None,
10872        port_forwarding=None,
10873        port_override=None,
10874        public_key=None,
10875        secret_store_id=None,
10876        tags=None,
10877        username=None,
10878    ):
10879        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10880        self.bind_interface = bind_interface if bind_interface is not None else ''
10881        '''
10882         Bind interface
10883        '''
10884        self.egress_filter = egress_filter if egress_filter is not None else ''
10885        '''
10886         A filter applied to the routing logic to pin datasource to nodes.
10887        '''
10888        self.healthy = healthy if healthy is not None else False
10889        '''
10890         True if the datasource is reachable and the credentials are valid.
10891        '''
10892        self.hostname = hostname if hostname is not None else ''
10893        self.id = id if id is not None else ''
10894        '''
10895         Unique identifier of the Resource.
10896        '''
10897        self.key_type = key_type if key_type is not None else ''
10898        self.name = name if name is not None else ''
10899        '''
10900         Unique human-readable name of the Resource.
10901        '''
10902        self.port = port if port is not None else 0
10903        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10904        self.port_override = port_override if port_override is not None else 0
10905        self.public_key = public_key if public_key is not None else ''
10906        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10907        '''
10908         ID of the secret store containing credentials for this resource, if any.
10909        '''
10910        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10911        '''
10912         Tags is a map of key, value pairs.
10913        '''
10914        self.username = username if username is not None else ''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

key_type
name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
public_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10935    def to_dict(self):
10936        return {
10937            'allow_deprecated_key_exchanges':
10938            self.allow_deprecated_key_exchanges,
10939            'bind_interface': self.bind_interface,
10940            'egress_filter': self.egress_filter,
10941            'healthy': self.healthy,
10942            'hostname': self.hostname,
10943            'id': self.id,
10944            'key_type': self.key_type,
10945            'name': self.name,
10946            'port': self.port,
10947            'port_forwarding': self.port_forwarding,
10948            'port_override': self.port_override,
10949            'public_key': self.public_key,
10950            'secret_store_id': self.secret_store_id,
10951            'tags': self.tags,
10952            'username': self.username,
10953        }
@classmethod
def from_dict(cls, d)
10955    @classmethod
10956    def from_dict(cls, d):
10957        return cls(
10958            allow_deprecated_key_exchanges=d.get(
10959                'allow_deprecated_key_exchanges'),
10960            bind_interface=d.get('bind_interface'),
10961            egress_filter=d.get('egress_filter'),
10962            healthy=d.get('healthy'),
10963            hostname=d.get('hostname'),
10964            id=d.get('id'),
10965            key_type=d.get('key_type'),
10966            name=d.get('name'),
10967            port=d.get('port'),
10968            port_forwarding=d.get('port_forwarding'),
10969            port_override=d.get('port_override'),
10970            public_key=d.get('public_key'),
10971            secret_store_id=d.get('secret_store_id'),
10972            tags=d.get('tags'),
10973            username=d.get('username'),
10974        )
class SSHCert:
10977class SSHCert:
10978    __slots__ = [
10979        'allow_deprecated_key_exchanges',
10980        'bind_interface',
10981        'egress_filter',
10982        'healthy',
10983        'hostname',
10984        'id',
10985        'key_type',
10986        'name',
10987        'port',
10988        'port_forwarding',
10989        'port_override',
10990        'remote_identity_group_id',
10991        'remote_identity_healthcheck_username',
10992        'secret_store_id',
10993        'tags',
10994        'username',
10995    ]
10996
10997    def __init__(
10998        self,
10999        allow_deprecated_key_exchanges=None,
11000        bind_interface=None,
11001        egress_filter=None,
11002        healthy=None,
11003        hostname=None,
11004        id=None,
11005        key_type=None,
11006        name=None,
11007        port=None,
11008        port_forwarding=None,
11009        port_override=None,
11010        remote_identity_group_id=None,
11011        remote_identity_healthcheck_username=None,
11012        secret_store_id=None,
11013        tags=None,
11014        username=None,
11015    ):
11016        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11017        self.bind_interface = bind_interface if bind_interface is not None else ''
11018        '''
11019         Bind interface
11020        '''
11021        self.egress_filter = egress_filter if egress_filter is not None else ''
11022        '''
11023         A filter applied to the routing logic to pin datasource to nodes.
11024        '''
11025        self.healthy = healthy if healthy is not None else False
11026        '''
11027         True if the datasource is reachable and the credentials are valid.
11028        '''
11029        self.hostname = hostname if hostname is not None else ''
11030        self.id = id if id is not None else ''
11031        '''
11032         Unique identifier of the Resource.
11033        '''
11034        self.key_type = key_type if key_type is not None else ''
11035        self.name = name if name is not None else ''
11036        '''
11037         Unique human-readable name of the Resource.
11038        '''
11039        self.port = port if port is not None else 0
11040        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11041        self.port_override = port_override if port_override is not None else 0
11042        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
11043        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
11044        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11045        '''
11046         ID of the secret store containing credentials for this resource, if any.
11047        '''
11048        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11049        '''
11050         Tags is a map of key, value pairs.
11051        '''
11052        self.username = username if username is not None else ''
11053
11054    def __repr__(self):
11055        return '<sdm.SSHCert ' + \
11056            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11057            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11058            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11059            'healthy: ' + repr(self.healthy) + ' ' +\
11060            'hostname: ' + repr(self.hostname) + ' ' +\
11061            'id: ' + repr(self.id) + ' ' +\
11062            'key_type: ' + repr(self.key_type) + ' ' +\
11063            'name: ' + repr(self.name) + ' ' +\
11064            'port: ' + repr(self.port) + ' ' +\
11065            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11066            'port_override: ' + repr(self.port_override) + ' ' +\
11067            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
11068            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
11069            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11070            'tags: ' + repr(self.tags) + ' ' +\
11071            'username: ' + repr(self.username) + ' ' +\
11072            '>'
11073
11074    def to_dict(self):
11075        return {
11076            'allow_deprecated_key_exchanges':
11077            self.allow_deprecated_key_exchanges,
11078            'bind_interface': self.bind_interface,
11079            'egress_filter': self.egress_filter,
11080            'healthy': self.healthy,
11081            'hostname': self.hostname,
11082            'id': self.id,
11083            'key_type': self.key_type,
11084            'name': self.name,
11085            'port': self.port,
11086            'port_forwarding': self.port_forwarding,
11087            'port_override': self.port_override,
11088            'remote_identity_group_id': self.remote_identity_group_id,
11089            'remote_identity_healthcheck_username':
11090            self.remote_identity_healthcheck_username,
11091            'secret_store_id': self.secret_store_id,
11092            'tags': self.tags,
11093            'username': self.username,
11094        }
11095
11096    @classmethod
11097    def from_dict(cls, d):
11098        return cls(
11099            allow_deprecated_key_exchanges=d.get(
11100                'allow_deprecated_key_exchanges'),
11101            bind_interface=d.get('bind_interface'),
11102            egress_filter=d.get('egress_filter'),
11103            healthy=d.get('healthy'),
11104            hostname=d.get('hostname'),
11105            id=d.get('id'),
11106            key_type=d.get('key_type'),
11107            name=d.get('name'),
11108            port=d.get('port'),
11109            port_forwarding=d.get('port_forwarding'),
11110            port_override=d.get('port_override'),
11111            remote_identity_group_id=d.get('remote_identity_group_id'),
11112            remote_identity_healthcheck_username=d.get(
11113                'remote_identity_healthcheck_username'),
11114            secret_store_id=d.get('secret_store_id'),
11115            tags=d.get('tags'),
11116            username=d.get('username'),
11117        )
SSHCert( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, key_type=None, name=None, port=None, port_forwarding=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, username=None)
10997    def __init__(
10998        self,
10999        allow_deprecated_key_exchanges=None,
11000        bind_interface=None,
11001        egress_filter=None,
11002        healthy=None,
11003        hostname=None,
11004        id=None,
11005        key_type=None,
11006        name=None,
11007        port=None,
11008        port_forwarding=None,
11009        port_override=None,
11010        remote_identity_group_id=None,
11011        remote_identity_healthcheck_username=None,
11012        secret_store_id=None,
11013        tags=None,
11014        username=None,
11015    ):
11016        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11017        self.bind_interface = bind_interface if bind_interface is not None else ''
11018        '''
11019         Bind interface
11020        '''
11021        self.egress_filter = egress_filter if egress_filter is not None else ''
11022        '''
11023         A filter applied to the routing logic to pin datasource to nodes.
11024        '''
11025        self.healthy = healthy if healthy is not None else False
11026        '''
11027         True if the datasource is reachable and the credentials are valid.
11028        '''
11029        self.hostname = hostname if hostname is not None else ''
11030        self.id = id if id is not None else ''
11031        '''
11032         Unique identifier of the Resource.
11033        '''
11034        self.key_type = key_type if key_type is not None else ''
11035        self.name = name if name is not None else ''
11036        '''
11037         Unique human-readable name of the Resource.
11038        '''
11039        self.port = port if port is not None else 0
11040        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11041        self.port_override = port_override if port_override is not None else 0
11042        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
11043        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
11044        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11045        '''
11046         ID of the secret store containing credentials for this resource, if any.
11047        '''
11048        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11049        '''
11050         Tags is a map of key, value pairs.
11051        '''
11052        self.username = username if username is not None else ''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

key_type
name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11074    def to_dict(self):
11075        return {
11076            'allow_deprecated_key_exchanges':
11077            self.allow_deprecated_key_exchanges,
11078            'bind_interface': self.bind_interface,
11079            'egress_filter': self.egress_filter,
11080            'healthy': self.healthy,
11081            'hostname': self.hostname,
11082            'id': self.id,
11083            'key_type': self.key_type,
11084            'name': self.name,
11085            'port': self.port,
11086            'port_forwarding': self.port_forwarding,
11087            'port_override': self.port_override,
11088            'remote_identity_group_id': self.remote_identity_group_id,
11089            'remote_identity_healthcheck_username':
11090            self.remote_identity_healthcheck_username,
11091            'secret_store_id': self.secret_store_id,
11092            'tags': self.tags,
11093            'username': self.username,
11094        }
@classmethod
def from_dict(cls, d)
11096    @classmethod
11097    def from_dict(cls, d):
11098        return cls(
11099            allow_deprecated_key_exchanges=d.get(
11100                'allow_deprecated_key_exchanges'),
11101            bind_interface=d.get('bind_interface'),
11102            egress_filter=d.get('egress_filter'),
11103            healthy=d.get('healthy'),
11104            hostname=d.get('hostname'),
11105            id=d.get('id'),
11106            key_type=d.get('key_type'),
11107            name=d.get('name'),
11108            port=d.get('port'),
11109            port_forwarding=d.get('port_forwarding'),
11110            port_override=d.get('port_override'),
11111            remote_identity_group_id=d.get('remote_identity_group_id'),
11112            remote_identity_healthcheck_username=d.get(
11113                'remote_identity_healthcheck_username'),
11114            secret_store_id=d.get('secret_store_id'),
11115            tags=d.get('tags'),
11116            username=d.get('username'),
11117        )
class SSHCustomerKey:
11120class SSHCustomerKey:
11121    __slots__ = [
11122        'allow_deprecated_key_exchanges',
11123        'bind_interface',
11124        'egress_filter',
11125        'healthy',
11126        'hostname',
11127        'id',
11128        'name',
11129        'port',
11130        'port_forwarding',
11131        'port_override',
11132        'private_key',
11133        'secret_store_id',
11134        'tags',
11135        'username',
11136    ]
11137
11138    def __init__(
11139        self,
11140        allow_deprecated_key_exchanges=None,
11141        bind_interface=None,
11142        egress_filter=None,
11143        healthy=None,
11144        hostname=None,
11145        id=None,
11146        name=None,
11147        port=None,
11148        port_forwarding=None,
11149        port_override=None,
11150        private_key=None,
11151        secret_store_id=None,
11152        tags=None,
11153        username=None,
11154    ):
11155        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11156        self.bind_interface = bind_interface if bind_interface is not None else ''
11157        '''
11158         Bind interface
11159        '''
11160        self.egress_filter = egress_filter if egress_filter is not None else ''
11161        '''
11162         A filter applied to the routing logic to pin datasource to nodes.
11163        '''
11164        self.healthy = healthy if healthy is not None else False
11165        '''
11166         True if the datasource is reachable and the credentials are valid.
11167        '''
11168        self.hostname = hostname if hostname is not None else ''
11169        self.id = id if id is not None else ''
11170        '''
11171         Unique identifier of the Resource.
11172        '''
11173        self.name = name if name is not None else ''
11174        '''
11175         Unique human-readable name of the Resource.
11176        '''
11177        self.port = port if port is not None else 0
11178        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11179        self.port_override = port_override if port_override is not None else 0
11180        self.private_key = private_key if private_key is not None else ''
11181        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11182        '''
11183         ID of the secret store containing credentials for this resource, if any.
11184        '''
11185        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11186        '''
11187         Tags is a map of key, value pairs.
11188        '''
11189        self.username = username if username is not None else ''
11190
11191    def __repr__(self):
11192        return '<sdm.SSHCustomerKey ' + \
11193            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11194            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11195            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11196            'healthy: ' + repr(self.healthy) + ' ' +\
11197            'hostname: ' + repr(self.hostname) + ' ' +\
11198            'id: ' + repr(self.id) + ' ' +\
11199            'name: ' + repr(self.name) + ' ' +\
11200            'port: ' + repr(self.port) + ' ' +\
11201            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11202            'port_override: ' + repr(self.port_override) + ' ' +\
11203            'private_key: ' + repr(self.private_key) + ' ' +\
11204            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11205            'tags: ' + repr(self.tags) + ' ' +\
11206            'username: ' + repr(self.username) + ' ' +\
11207            '>'
11208
11209    def to_dict(self):
11210        return {
11211            'allow_deprecated_key_exchanges':
11212            self.allow_deprecated_key_exchanges,
11213            'bind_interface': self.bind_interface,
11214            'egress_filter': self.egress_filter,
11215            'healthy': self.healthy,
11216            'hostname': self.hostname,
11217            'id': self.id,
11218            'name': self.name,
11219            'port': self.port,
11220            'port_forwarding': self.port_forwarding,
11221            'port_override': self.port_override,
11222            'private_key': self.private_key,
11223            'secret_store_id': self.secret_store_id,
11224            'tags': self.tags,
11225            'username': self.username,
11226        }
11227
11228    @classmethod
11229    def from_dict(cls, d):
11230        return cls(
11231            allow_deprecated_key_exchanges=d.get(
11232                'allow_deprecated_key_exchanges'),
11233            bind_interface=d.get('bind_interface'),
11234            egress_filter=d.get('egress_filter'),
11235            healthy=d.get('healthy'),
11236            hostname=d.get('hostname'),
11237            id=d.get('id'),
11238            name=d.get('name'),
11239            port=d.get('port'),
11240            port_forwarding=d.get('port_forwarding'),
11241            port_override=d.get('port_override'),
11242            private_key=d.get('private_key'),
11243            secret_store_id=d.get('secret_store_id'),
11244            tags=d.get('tags'),
11245            username=d.get('username'),
11246        )
SSHCustomerKey( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_forwarding=None, port_override=None, private_key=None, secret_store_id=None, tags=None, username=None)
11138    def __init__(
11139        self,
11140        allow_deprecated_key_exchanges=None,
11141        bind_interface=None,
11142        egress_filter=None,
11143        healthy=None,
11144        hostname=None,
11145        id=None,
11146        name=None,
11147        port=None,
11148        port_forwarding=None,
11149        port_override=None,
11150        private_key=None,
11151        secret_store_id=None,
11152        tags=None,
11153        username=None,
11154    ):
11155        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11156        self.bind_interface = bind_interface if bind_interface is not None else ''
11157        '''
11158         Bind interface
11159        '''
11160        self.egress_filter = egress_filter if egress_filter is not None else ''
11161        '''
11162         A filter applied to the routing logic to pin datasource to nodes.
11163        '''
11164        self.healthy = healthy if healthy is not None else False
11165        '''
11166         True if the datasource is reachable and the credentials are valid.
11167        '''
11168        self.hostname = hostname if hostname is not None else ''
11169        self.id = id if id is not None else ''
11170        '''
11171         Unique identifier of the Resource.
11172        '''
11173        self.name = name if name is not None else ''
11174        '''
11175         Unique human-readable name of the Resource.
11176        '''
11177        self.port = port if port is not None else 0
11178        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11179        self.port_override = port_override if port_override is not None else 0
11180        self.private_key = private_key if private_key is not None else ''
11181        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11182        '''
11183         ID of the secret store containing credentials for this resource, if any.
11184        '''
11185        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11186        '''
11187         Tags is a map of key, value pairs.
11188        '''
11189        self.username = username if username is not None else ''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
private_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11209    def to_dict(self):
11210        return {
11211            'allow_deprecated_key_exchanges':
11212            self.allow_deprecated_key_exchanges,
11213            'bind_interface': self.bind_interface,
11214            'egress_filter': self.egress_filter,
11215            'healthy': self.healthy,
11216            'hostname': self.hostname,
11217            'id': self.id,
11218            'name': self.name,
11219            'port': self.port,
11220            'port_forwarding': self.port_forwarding,
11221            'port_override': self.port_override,
11222            'private_key': self.private_key,
11223            'secret_store_id': self.secret_store_id,
11224            'tags': self.tags,
11225            'username': self.username,
11226        }
@classmethod
def from_dict(cls, d)
11228    @classmethod
11229    def from_dict(cls, d):
11230        return cls(
11231            allow_deprecated_key_exchanges=d.get(
11232                'allow_deprecated_key_exchanges'),
11233            bind_interface=d.get('bind_interface'),
11234            egress_filter=d.get('egress_filter'),
11235            healthy=d.get('healthy'),
11236            hostname=d.get('hostname'),
11237            id=d.get('id'),
11238            name=d.get('name'),
11239            port=d.get('port'),
11240            port_forwarding=d.get('port_forwarding'),
11241            port_override=d.get('port_override'),
11242            private_key=d.get('private_key'),
11243            secret_store_id=d.get('secret_store_id'),
11244            tags=d.get('tags'),
11245            username=d.get('username'),
11246        )
class SecretStoreCreateResponse:
11249class SecretStoreCreateResponse:
11250    '''
11251         SecretStoreCreateResponse reports how the SecretStores were created in the system.
11252    '''
11253    __slots__ = [
11254        'meta',
11255        'rate_limit',
11256        'secret_store',
11257    ]
11258
11259    def __init__(
11260        self,
11261        meta=None,
11262        rate_limit=None,
11263        secret_store=None,
11264    ):
11265        self.meta = meta if meta is not None else None
11266        '''
11267         Reserved for future use.
11268        '''
11269        self.rate_limit = rate_limit if rate_limit is not None else None
11270        '''
11271         Rate limit information.
11272        '''
11273        self.secret_store = secret_store if secret_store is not None else None
11274        '''
11275         The created SecretStore.
11276        '''
11277
11278    def __repr__(self):
11279        return '<sdm.SecretStoreCreateResponse ' + \
11280            'meta: ' + repr(self.meta) + ' ' +\
11281            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11282            'secret_store: ' + repr(self.secret_store) + ' ' +\
11283            '>'
11284
11285    def to_dict(self):
11286        return {
11287            'meta': self.meta,
11288            'rate_limit': self.rate_limit,
11289            'secret_store': self.secret_store,
11290        }
11291
11292    @classmethod
11293    def from_dict(cls, d):
11294        return cls(
11295            meta=d.get('meta'),
11296            rate_limit=d.get('rate_limit'),
11297            secret_store=d.get('secret_store'),
11298        )

SecretStoreCreateResponse reports how the SecretStores were created in the system.

SecretStoreCreateResponse(meta=None, rate_limit=None, secret_store=None)
11259    def __init__(
11260        self,
11261        meta=None,
11262        rate_limit=None,
11263        secret_store=None,
11264    ):
11265        self.meta = meta if meta is not None else None
11266        '''
11267         Reserved for future use.
11268        '''
11269        self.rate_limit = rate_limit if rate_limit is not None else None
11270        '''
11271         Rate limit information.
11272        '''
11273        self.secret_store = secret_store if secret_store is not None else None
11274        '''
11275         The created SecretStore.
11276        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The created SecretStore.

def to_dict(self)
11285    def to_dict(self):
11286        return {
11287            'meta': self.meta,
11288            'rate_limit': self.rate_limit,
11289            'secret_store': self.secret_store,
11290        }
@classmethod
def from_dict(cls, d)
11292    @classmethod
11293    def from_dict(cls, d):
11294        return cls(
11295            meta=d.get('meta'),
11296            rate_limit=d.get('rate_limit'),
11297            secret_store=d.get('secret_store'),
11298        )
class SecretStoreDeleteResponse:
11301class SecretStoreDeleteResponse:
11302    '''
11303         SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
11304    '''
11305    __slots__ = [
11306        'meta',
11307        'rate_limit',
11308    ]
11309
11310    def __init__(
11311        self,
11312        meta=None,
11313        rate_limit=None,
11314    ):
11315        self.meta = meta if meta is not None else None
11316        '''
11317         Reserved for future use.
11318        '''
11319        self.rate_limit = rate_limit if rate_limit is not None else None
11320        '''
11321         Rate limit information.
11322        '''
11323
11324    def __repr__(self):
11325        return '<sdm.SecretStoreDeleteResponse ' + \
11326            'meta: ' + repr(self.meta) + ' ' +\
11327            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11328            '>'
11329
11330    def to_dict(self):
11331        return {
11332            'meta': self.meta,
11333            'rate_limit': self.rate_limit,
11334        }
11335
11336    @classmethod
11337    def from_dict(cls, d):
11338        return cls(
11339            meta=d.get('meta'),
11340            rate_limit=d.get('rate_limit'),
11341        )

SecretStoreDeleteResponse returns information about a SecretStore that was deleted.

SecretStoreDeleteResponse(meta=None, rate_limit=None)
11310    def __init__(
11311        self,
11312        meta=None,
11313        rate_limit=None,
11314    ):
11315        self.meta = meta if meta is not None else None
11316        '''
11317         Reserved for future use.
11318        '''
11319        self.rate_limit = rate_limit if rate_limit is not None else None
11320        '''
11321         Rate limit information.
11322        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
11330    def to_dict(self):
11331        return {
11332            'meta': self.meta,
11333            'rate_limit': self.rate_limit,
11334        }
@classmethod
def from_dict(cls, d)
11336    @classmethod
11337    def from_dict(cls, d):
11338        return cls(
11339            meta=d.get('meta'),
11340            rate_limit=d.get('rate_limit'),
11341        )
class SecretStoreGetResponse:
11344class SecretStoreGetResponse:
11345    '''
11346         SecretStoreGetResponse returns a requested SecretStore.
11347    '''
11348    __slots__ = [
11349        'meta',
11350        'rate_limit',
11351        'secret_store',
11352    ]
11353
11354    def __init__(
11355        self,
11356        meta=None,
11357        rate_limit=None,
11358        secret_store=None,
11359    ):
11360        self.meta = meta if meta is not None else None
11361        '''
11362         Reserved for future use.
11363        '''
11364        self.rate_limit = rate_limit if rate_limit is not None else None
11365        '''
11366         Rate limit information.
11367        '''
11368        self.secret_store = secret_store if secret_store is not None else None
11369        '''
11370         The requested SecretStore.
11371        '''
11372
11373    def __repr__(self):
11374        return '<sdm.SecretStoreGetResponse ' + \
11375            'meta: ' + repr(self.meta) + ' ' +\
11376            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11377            'secret_store: ' + repr(self.secret_store) + ' ' +\
11378            '>'
11379
11380    def to_dict(self):
11381        return {
11382            'meta': self.meta,
11383            'rate_limit': self.rate_limit,
11384            'secret_store': self.secret_store,
11385        }
11386
11387    @classmethod
11388    def from_dict(cls, d):
11389        return cls(
11390            meta=d.get('meta'),
11391            rate_limit=d.get('rate_limit'),
11392            secret_store=d.get('secret_store'),
11393        )

SecretStoreGetResponse returns a requested SecretStore.

SecretStoreGetResponse(meta=None, rate_limit=None, secret_store=None)
11354    def __init__(
11355        self,
11356        meta=None,
11357        rate_limit=None,
11358        secret_store=None,
11359    ):
11360        self.meta = meta if meta is not None else None
11361        '''
11362         Reserved for future use.
11363        '''
11364        self.rate_limit = rate_limit if rate_limit is not None else None
11365        '''
11366         Rate limit information.
11367        '''
11368        self.secret_store = secret_store if secret_store is not None else None
11369        '''
11370         The requested SecretStore.
11371        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The requested SecretStore.

def to_dict(self)
11380    def to_dict(self):
11381        return {
11382            'meta': self.meta,
11383            'rate_limit': self.rate_limit,
11384            'secret_store': self.secret_store,
11385        }
@classmethod
def from_dict(cls, d)
11387    @classmethod
11388    def from_dict(cls, d):
11389        return cls(
11390            meta=d.get('meta'),
11391            rate_limit=d.get('rate_limit'),
11392            secret_store=d.get('secret_store'),
11393        )
class SecretStoreUpdateResponse:
11396class SecretStoreUpdateResponse:
11397    '''
11398         SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
11399     a SecretStoreUpdateRequest.
11400    '''
11401    __slots__ = [
11402        'meta',
11403        'rate_limit',
11404        'secret_store',
11405    ]
11406
11407    def __init__(
11408        self,
11409        meta=None,
11410        rate_limit=None,
11411        secret_store=None,
11412    ):
11413        self.meta = meta if meta is not None else None
11414        '''
11415         Reserved for future use.
11416        '''
11417        self.rate_limit = rate_limit if rate_limit is not None else None
11418        '''
11419         Rate limit information.
11420        '''
11421        self.secret_store = secret_store if secret_store is not None else None
11422        '''
11423         The updated SecretStore.
11424        '''
11425
11426    def __repr__(self):
11427        return '<sdm.SecretStoreUpdateResponse ' + \
11428            'meta: ' + repr(self.meta) + ' ' +\
11429            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11430            'secret_store: ' + repr(self.secret_store) + ' ' +\
11431            '>'
11432
11433    def to_dict(self):
11434        return {
11435            'meta': self.meta,
11436            'rate_limit': self.rate_limit,
11437            'secret_store': self.secret_store,
11438        }
11439
11440    @classmethod
11441    def from_dict(cls, d):
11442        return cls(
11443            meta=d.get('meta'),
11444            rate_limit=d.get('rate_limit'),
11445            secret_store=d.get('secret_store'),
11446        )

SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by a SecretStoreUpdateRequest.

SecretStoreUpdateResponse(meta=None, rate_limit=None, secret_store=None)
11407    def __init__(
11408        self,
11409        meta=None,
11410        rate_limit=None,
11411        secret_store=None,
11412    ):
11413        self.meta = meta if meta is not None else None
11414        '''
11415         Reserved for future use.
11416        '''
11417        self.rate_limit = rate_limit if rate_limit is not None else None
11418        '''
11419         Rate limit information.
11420        '''
11421        self.secret_store = secret_store if secret_store is not None else None
11422        '''
11423         The updated SecretStore.
11424        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The updated SecretStore.

def to_dict(self)
11433    def to_dict(self):
11434        return {
11435            'meta': self.meta,
11436            'rate_limit': self.rate_limit,
11437            'secret_store': self.secret_store,
11438        }
@classmethod
def from_dict(cls, d)
11440    @classmethod
11441    def from_dict(cls, d):
11442        return cls(
11443            meta=d.get('meta'),
11444            rate_limit=d.get('rate_limit'),
11445            secret_store=d.get('secret_store'),
11446        )
class Service:
11449class Service:
11450    '''
11451         A Service is a service account that can connect to resources they are granted
11452     directly, or granted via roles. Services are typically automated jobs.
11453    '''
11454    __slots__ = [
11455        'id',
11456        'name',
11457        'suspended',
11458        'tags',
11459    ]
11460
11461    def __init__(
11462        self,
11463        id=None,
11464        name=None,
11465        suspended=None,
11466        tags=None,
11467    ):
11468        self.id = id if id is not None else ''
11469        '''
11470         Unique identifier of the Service.
11471        '''
11472        self.name = name if name is not None else ''
11473        '''
11474         Unique human-readable name of the Service.
11475        '''
11476        self.suspended = suspended if suspended is not None else False
11477        '''
11478         The Service's suspended state.
11479        '''
11480        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11481        '''
11482         Tags is a map of key, value pairs.
11483        '''
11484
11485    def __repr__(self):
11486        return '<sdm.Service ' + \
11487            'id: ' + repr(self.id) + ' ' +\
11488            'name: ' + repr(self.name) + ' ' +\
11489            'suspended: ' + repr(self.suspended) + ' ' +\
11490            'tags: ' + repr(self.tags) + ' ' +\
11491            '>'
11492
11493    def to_dict(self):
11494        return {
11495            'id': self.id,
11496            'name': self.name,
11497            'suspended': self.suspended,
11498            'tags': self.tags,
11499        }
11500
11501    @classmethod
11502    def from_dict(cls, d):
11503        return cls(
11504            id=d.get('id'),
11505            name=d.get('name'),
11506            suspended=d.get('suspended'),
11507            tags=d.get('tags'),
11508        )

A Service is a service account that can connect to resources they are granted directly, or granted via roles. Services are typically automated jobs.

Service(id=None, name=None, suspended=None, tags=None)
11461    def __init__(
11462        self,
11463        id=None,
11464        name=None,
11465        suspended=None,
11466        tags=None,
11467    ):
11468        self.id = id if id is not None else ''
11469        '''
11470         Unique identifier of the Service.
11471        '''
11472        self.name = name if name is not None else ''
11473        '''
11474         Unique human-readable name of the Service.
11475        '''
11476        self.suspended = suspended if suspended is not None else False
11477        '''
11478         The Service's suspended state.
11479        '''
11480        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11481        '''
11482         Tags is a map of key, value pairs.
11483        '''
id

Unique identifier of the Service.

name

Unique human-readable name of the Service.

suspended

The Service's suspended state.

tags

Tags is a map of key, value pairs.

def to_dict(self)
11493    def to_dict(self):
11494        return {
11495            'id': self.id,
11496            'name': self.name,
11497            'suspended': self.suspended,
11498            'tags': self.tags,
11499        }
@classmethod
def from_dict(cls, d)
11501    @classmethod
11502    def from_dict(cls, d):
11503        return cls(
11504            id=d.get('id'),
11505            name=d.get('name'),
11506            suspended=d.get('suspended'),
11507            tags=d.get('tags'),
11508        )
class SingleStore:
11511class SingleStore:
11512    __slots__ = [
11513        'bind_interface',
11514        'database',
11515        'egress_filter',
11516        'healthy',
11517        'hostname',
11518        'id',
11519        'name',
11520        'password',
11521        'port',
11522        'port_override',
11523        'secret_store_id',
11524        'tags',
11525        'username',
11526    ]
11527
11528    def __init__(
11529        self,
11530        bind_interface=None,
11531        database=None,
11532        egress_filter=None,
11533        healthy=None,
11534        hostname=None,
11535        id=None,
11536        name=None,
11537        password=None,
11538        port=None,
11539        port_override=None,
11540        secret_store_id=None,
11541        tags=None,
11542        username=None,
11543    ):
11544        self.bind_interface = bind_interface if bind_interface is not None else ''
11545        '''
11546         Bind interface
11547        '''
11548        self.database = database if database is not None else ''
11549        self.egress_filter = egress_filter if egress_filter is not None else ''
11550        '''
11551         A filter applied to the routing logic to pin datasource to nodes.
11552        '''
11553        self.healthy = healthy if healthy is not None else False
11554        '''
11555         True if the datasource is reachable and the credentials are valid.
11556        '''
11557        self.hostname = hostname if hostname is not None else ''
11558        self.id = id if id is not None else ''
11559        '''
11560         Unique identifier of the Resource.
11561        '''
11562        self.name = name if name is not None else ''
11563        '''
11564         Unique human-readable name of the Resource.
11565        '''
11566        self.password = password if password is not None else ''
11567        self.port = port if port is not None else 0
11568        self.port_override = port_override if port_override is not None else 0
11569        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11570        '''
11571         ID of the secret store containing credentials for this resource, if any.
11572        '''
11573        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11574        '''
11575         Tags is a map of key, value pairs.
11576        '''
11577        self.username = username if username is not None else ''
11578
11579    def __repr__(self):
11580        return '<sdm.SingleStore ' + \
11581            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11582            'database: ' + repr(self.database) + ' ' +\
11583            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11584            'healthy: ' + repr(self.healthy) + ' ' +\
11585            'hostname: ' + repr(self.hostname) + ' ' +\
11586            'id: ' + repr(self.id) + ' ' +\
11587            'name: ' + repr(self.name) + ' ' +\
11588            'password: ' + repr(self.password) + ' ' +\
11589            'port: ' + repr(self.port) + ' ' +\
11590            'port_override: ' + repr(self.port_override) + ' ' +\
11591            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11592            'tags: ' + repr(self.tags) + ' ' +\
11593            'username: ' + repr(self.username) + ' ' +\
11594            '>'
11595
11596    def to_dict(self):
11597        return {
11598            'bind_interface': self.bind_interface,
11599            'database': self.database,
11600            'egress_filter': self.egress_filter,
11601            'healthy': self.healthy,
11602            'hostname': self.hostname,
11603            'id': self.id,
11604            'name': self.name,
11605            'password': self.password,
11606            'port': self.port,
11607            'port_override': self.port_override,
11608            'secret_store_id': self.secret_store_id,
11609            'tags': self.tags,
11610            'username': self.username,
11611        }
11612
11613    @classmethod
11614    def from_dict(cls, d):
11615        return cls(
11616            bind_interface=d.get('bind_interface'),
11617            database=d.get('database'),
11618            egress_filter=d.get('egress_filter'),
11619            healthy=d.get('healthy'),
11620            hostname=d.get('hostname'),
11621            id=d.get('id'),
11622            name=d.get('name'),
11623            password=d.get('password'),
11624            port=d.get('port'),
11625            port_override=d.get('port_override'),
11626            secret_store_id=d.get('secret_store_id'),
11627            tags=d.get('tags'),
11628            username=d.get('username'),
11629        )
SingleStore( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
11528    def __init__(
11529        self,
11530        bind_interface=None,
11531        database=None,
11532        egress_filter=None,
11533        healthy=None,
11534        hostname=None,
11535        id=None,
11536        name=None,
11537        password=None,
11538        port=None,
11539        port_override=None,
11540        secret_store_id=None,
11541        tags=None,
11542        username=None,
11543    ):
11544        self.bind_interface = bind_interface if bind_interface is not None else ''
11545        '''
11546         Bind interface
11547        '''
11548        self.database = database if database is not None else ''
11549        self.egress_filter = egress_filter if egress_filter is not None else ''
11550        '''
11551         A filter applied to the routing logic to pin datasource to nodes.
11552        '''
11553        self.healthy = healthy if healthy is not None else False
11554        '''
11555         True if the datasource is reachable and the credentials are valid.
11556        '''
11557        self.hostname = hostname if hostname is not None else ''
11558        self.id = id if id is not None else ''
11559        '''
11560         Unique identifier of the Resource.
11561        '''
11562        self.name = name if name is not None else ''
11563        '''
11564         Unique human-readable name of the Resource.
11565        '''
11566        self.password = password if password is not None else ''
11567        self.port = port if port is not None else 0
11568        self.port_override = port_override if port_override is not None else 0
11569        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11570        '''
11571         ID of the secret store containing credentials for this resource, if any.
11572        '''
11573        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11574        '''
11575         Tags is a map of key, value pairs.
11576        '''
11577        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11596    def to_dict(self):
11597        return {
11598            'bind_interface': self.bind_interface,
11599            'database': self.database,
11600            'egress_filter': self.egress_filter,
11601            'healthy': self.healthy,
11602            'hostname': self.hostname,
11603            'id': self.id,
11604            'name': self.name,
11605            'password': self.password,
11606            'port': self.port,
11607            'port_override': self.port_override,
11608            'secret_store_id': self.secret_store_id,
11609            'tags': self.tags,
11610            'username': self.username,
11611        }
@classmethod
def from_dict(cls, d)
11613    @classmethod
11614    def from_dict(cls, d):
11615        return cls(
11616            bind_interface=d.get('bind_interface'),
11617            database=d.get('database'),
11618            egress_filter=d.get('egress_filter'),
11619            healthy=d.get('healthy'),
11620            hostname=d.get('hostname'),
11621            id=d.get('id'),
11622            name=d.get('name'),
11623            password=d.get('password'),
11624            port=d.get('port'),
11625            port_override=d.get('port_override'),
11626            secret_store_id=d.get('secret_store_id'),
11627            tags=d.get('tags'),
11628            username=d.get('username'),
11629        )
class Snowflake:
11632class Snowflake:
11633    __slots__ = [
11634        'bind_interface',
11635        'database',
11636        'egress_filter',
11637        'healthy',
11638        'hostname',
11639        'id',
11640        'name',
11641        'password',
11642        'port_override',
11643        'schema',
11644        'secret_store_id',
11645        'tags',
11646        'username',
11647    ]
11648
11649    def __init__(
11650        self,
11651        bind_interface=None,
11652        database=None,
11653        egress_filter=None,
11654        healthy=None,
11655        hostname=None,
11656        id=None,
11657        name=None,
11658        password=None,
11659        port_override=None,
11660        schema=None,
11661        secret_store_id=None,
11662        tags=None,
11663        username=None,
11664    ):
11665        self.bind_interface = bind_interface if bind_interface is not None else ''
11666        '''
11667         Bind interface
11668        '''
11669        self.database = database if database is not None else ''
11670        self.egress_filter = egress_filter if egress_filter is not None else ''
11671        '''
11672         A filter applied to the routing logic to pin datasource to nodes.
11673        '''
11674        self.healthy = healthy if healthy is not None else False
11675        '''
11676         True if the datasource is reachable and the credentials are valid.
11677        '''
11678        self.hostname = hostname if hostname is not None else ''
11679        self.id = id if id is not None else ''
11680        '''
11681         Unique identifier of the Resource.
11682        '''
11683        self.name = name if name is not None else ''
11684        '''
11685         Unique human-readable name of the Resource.
11686        '''
11687        self.password = password if password is not None else ''
11688        self.port_override = port_override if port_override is not None else 0
11689        self.schema = schema if schema is not None else ''
11690        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11691        '''
11692         ID of the secret store containing credentials for this resource, if any.
11693        '''
11694        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11695        '''
11696         Tags is a map of key, value pairs.
11697        '''
11698        self.username = username if username is not None else ''
11699
11700    def __repr__(self):
11701        return '<sdm.Snowflake ' + \
11702            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11703            'database: ' + repr(self.database) + ' ' +\
11704            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11705            'healthy: ' + repr(self.healthy) + ' ' +\
11706            'hostname: ' + repr(self.hostname) + ' ' +\
11707            'id: ' + repr(self.id) + ' ' +\
11708            'name: ' + repr(self.name) + ' ' +\
11709            'password: ' + repr(self.password) + ' ' +\
11710            'port_override: ' + repr(self.port_override) + ' ' +\
11711            'schema: ' + repr(self.schema) + ' ' +\
11712            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11713            'tags: ' + repr(self.tags) + ' ' +\
11714            'username: ' + repr(self.username) + ' ' +\
11715            '>'
11716
11717    def to_dict(self):
11718        return {
11719            'bind_interface': self.bind_interface,
11720            'database': self.database,
11721            'egress_filter': self.egress_filter,
11722            'healthy': self.healthy,
11723            'hostname': self.hostname,
11724            'id': self.id,
11725            'name': self.name,
11726            'password': self.password,
11727            'port_override': self.port_override,
11728            'schema': self.schema,
11729            'secret_store_id': self.secret_store_id,
11730            'tags': self.tags,
11731            'username': self.username,
11732        }
11733
11734    @classmethod
11735    def from_dict(cls, d):
11736        return cls(
11737            bind_interface=d.get('bind_interface'),
11738            database=d.get('database'),
11739            egress_filter=d.get('egress_filter'),
11740            healthy=d.get('healthy'),
11741            hostname=d.get('hostname'),
11742            id=d.get('id'),
11743            name=d.get('name'),
11744            password=d.get('password'),
11745            port_override=d.get('port_override'),
11746            schema=d.get('schema'),
11747            secret_store_id=d.get('secret_store_id'),
11748            tags=d.get('tags'),
11749            username=d.get('username'),
11750        )
Snowflake( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None)
11649    def __init__(
11650        self,
11651        bind_interface=None,
11652        database=None,
11653        egress_filter=None,
11654        healthy=None,
11655        hostname=None,
11656        id=None,
11657        name=None,
11658        password=None,
11659        port_override=None,
11660        schema=None,
11661        secret_store_id=None,
11662        tags=None,
11663        username=None,
11664    ):
11665        self.bind_interface = bind_interface if bind_interface is not None else ''
11666        '''
11667         Bind interface
11668        '''
11669        self.database = database if database is not None else ''
11670        self.egress_filter = egress_filter if egress_filter is not None else ''
11671        '''
11672         A filter applied to the routing logic to pin datasource to nodes.
11673        '''
11674        self.healthy = healthy if healthy is not None else False
11675        '''
11676         True if the datasource is reachable and the credentials are valid.
11677        '''
11678        self.hostname = hostname if hostname is not None else ''
11679        self.id = id if id is not None else ''
11680        '''
11681         Unique identifier of the Resource.
11682        '''
11683        self.name = name if name is not None else ''
11684        '''
11685         Unique human-readable name of the Resource.
11686        '''
11687        self.password = password if password is not None else ''
11688        self.port_override = port_override if port_override is not None else 0
11689        self.schema = schema if schema is not None else ''
11690        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11691        '''
11692         ID of the secret store containing credentials for this resource, if any.
11693        '''
11694        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11695        '''
11696         Tags is a map of key, value pairs.
11697        '''
11698        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
schema
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11717    def to_dict(self):
11718        return {
11719            'bind_interface': self.bind_interface,
11720            'database': self.database,
11721            'egress_filter': self.egress_filter,
11722            'healthy': self.healthy,
11723            'hostname': self.hostname,
11724            'id': self.id,
11725            'name': self.name,
11726            'password': self.password,
11727            'port_override': self.port_override,
11728            'schema': self.schema,
11729            'secret_store_id': self.secret_store_id,
11730            'tags': self.tags,
11731            'username': self.username,
11732        }
@classmethod
def from_dict(cls, d)
11734    @classmethod
11735    def from_dict(cls, d):
11736        return cls(
11737            bind_interface=d.get('bind_interface'),
11738            database=d.get('database'),
11739            egress_filter=d.get('egress_filter'),
11740            healthy=d.get('healthy'),
11741            hostname=d.get('hostname'),
11742            id=d.get('id'),
11743            name=d.get('name'),
11744            password=d.get('password'),
11745            port_override=d.get('port_override'),
11746            schema=d.get('schema'),
11747            secret_store_id=d.get('secret_store_id'),
11748            tags=d.get('tags'),
11749            username=d.get('username'),
11750        )
class Snowsight:
11753class Snowsight:
11754    '''
11755    Snowsight is currently unstable, and its API may change, or it may be removed,
11756    without a major version bump.
11757    '''
11758    __slots__ = [
11759        'bind_interface',
11760        'egress_filter',
11761        'healthcheck_username',
11762        'healthy',
11763        'id',
11764        'name',
11765        'port_override',
11766        'samlmetadata',
11767        'secret_store_id',
11768        'subdomain',
11769        'tags',
11770    ]
11771
11772    def __init__(
11773        self,
11774        bind_interface=None,
11775        egress_filter=None,
11776        healthcheck_username=None,
11777        healthy=None,
11778        id=None,
11779        name=None,
11780        port_override=None,
11781        samlmetadata=None,
11782        secret_store_id=None,
11783        subdomain=None,
11784        tags=None,
11785    ):
11786        self.bind_interface = bind_interface if bind_interface is not None else ''
11787        '''
11788         Bind interface
11789        '''
11790        self.egress_filter = egress_filter if egress_filter is not None else ''
11791        '''
11792         A filter applied to the routing logic to pin datasource to nodes.
11793        '''
11794        self.healthcheck_username = healthcheck_username if healthcheck_username is not None else ''
11795        self.healthy = healthy if healthy is not None else False
11796        '''
11797         True if the datasource is reachable and the credentials are valid.
11798        '''
11799        self.id = id if id is not None else ''
11800        '''
11801         Unique identifier of the Resource.
11802        '''
11803        self.name = name if name is not None else ''
11804        '''
11805         Unique human-readable name of the Resource.
11806        '''
11807        self.port_override = port_override if port_override is not None else 0
11808        self.samlmetadata = samlmetadata if samlmetadata is not None else ''
11809        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11810        '''
11811         ID of the secret store containing credentials for this resource, if any.
11812        '''
11813        self.subdomain = subdomain if subdomain is not None else ''
11814        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11815        '''
11816         Tags is a map of key, value pairs.
11817        '''
11818
11819    def __repr__(self):
11820        return '<sdm.Snowsight ' + \
11821            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11822            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11823            'healthcheck_username: ' + repr(self.healthcheck_username) + ' ' +\
11824            'healthy: ' + repr(self.healthy) + ' ' +\
11825            'id: ' + repr(self.id) + ' ' +\
11826            'name: ' + repr(self.name) + ' ' +\
11827            'port_override: ' + repr(self.port_override) + ' ' +\
11828            'samlmetadata: ' + repr(self.samlmetadata) + ' ' +\
11829            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11830            'subdomain: ' + repr(self.subdomain) + ' ' +\
11831            'tags: ' + repr(self.tags) + ' ' +\
11832            '>'
11833
11834    def to_dict(self):
11835        return {
11836            'bind_interface': self.bind_interface,
11837            'egress_filter': self.egress_filter,
11838            'healthcheck_username': self.healthcheck_username,
11839            'healthy': self.healthy,
11840            'id': self.id,
11841            'name': self.name,
11842            'port_override': self.port_override,
11843            'samlmetadata': self.samlmetadata,
11844            'secret_store_id': self.secret_store_id,
11845            'subdomain': self.subdomain,
11846            'tags': self.tags,
11847        }
11848
11849    @classmethod
11850    def from_dict(cls, d):
11851        return cls(
11852            bind_interface=d.get('bind_interface'),
11853            egress_filter=d.get('egress_filter'),
11854            healthcheck_username=d.get('healthcheck_username'),
11855            healthy=d.get('healthy'),
11856            id=d.get('id'),
11857            name=d.get('name'),
11858            port_override=d.get('port_override'),
11859            samlmetadata=d.get('samlmetadata'),
11860            secret_store_id=d.get('secret_store_id'),
11861            subdomain=d.get('subdomain'),
11862            tags=d.get('tags'),
11863        )

Snowsight is currently unstable, and its API may change, or it may be removed, without a major version bump.

Snowsight( bind_interface=None, egress_filter=None, healthcheck_username=None, healthy=None, id=None, name=None, port_override=None, samlmetadata=None, secret_store_id=None, subdomain=None, tags=None)
11772    def __init__(
11773        self,
11774        bind_interface=None,
11775        egress_filter=None,
11776        healthcheck_username=None,
11777        healthy=None,
11778        id=None,
11779        name=None,
11780        port_override=None,
11781        samlmetadata=None,
11782        secret_store_id=None,
11783        subdomain=None,
11784        tags=None,
11785    ):
11786        self.bind_interface = bind_interface if bind_interface is not None else ''
11787        '''
11788         Bind interface
11789        '''
11790        self.egress_filter = egress_filter if egress_filter is not None else ''
11791        '''
11792         A filter applied to the routing logic to pin datasource to nodes.
11793        '''
11794        self.healthcheck_username = healthcheck_username if healthcheck_username is not None else ''
11795        self.healthy = healthy if healthy is not None else False
11796        '''
11797         True if the datasource is reachable and the credentials are valid.
11798        '''
11799        self.id = id if id is not None else ''
11800        '''
11801         Unique identifier of the Resource.
11802        '''
11803        self.name = name if name is not None else ''
11804        '''
11805         Unique human-readable name of the Resource.
11806        '''
11807        self.port_override = port_override if port_override is not None else 0
11808        self.samlmetadata = samlmetadata if samlmetadata is not None else ''
11809        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11810        '''
11811         ID of the secret store containing credentials for this resource, if any.
11812        '''
11813        self.subdomain = subdomain if subdomain is not None else ''
11814        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11815        '''
11816         Tags is a map of key, value pairs.
11817        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_username
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
samlmetadata
secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

def to_dict(self)
11834    def to_dict(self):
11835        return {
11836            'bind_interface': self.bind_interface,
11837            'egress_filter': self.egress_filter,
11838            'healthcheck_username': self.healthcheck_username,
11839            'healthy': self.healthy,
11840            'id': self.id,
11841            'name': self.name,
11842            'port_override': self.port_override,
11843            'samlmetadata': self.samlmetadata,
11844            'secret_store_id': self.secret_store_id,
11845            'subdomain': self.subdomain,
11846            'tags': self.tags,
11847        }
@classmethod
def from_dict(cls, d)
11849    @classmethod
11850    def from_dict(cls, d):
11851        return cls(
11852            bind_interface=d.get('bind_interface'),
11853            egress_filter=d.get('egress_filter'),
11854            healthcheck_username=d.get('healthcheck_username'),
11855            healthy=d.get('healthy'),
11856            id=d.get('id'),
11857            name=d.get('name'),
11858            port_override=d.get('port_override'),
11859            samlmetadata=d.get('samlmetadata'),
11860            secret_store_id=d.get('secret_store_id'),
11861            subdomain=d.get('subdomain'),
11862            tags=d.get('tags'),
11863        )
class Sybase:
11866class Sybase:
11867    __slots__ = [
11868        'bind_interface',
11869        'egress_filter',
11870        'healthy',
11871        'hostname',
11872        'id',
11873        'name',
11874        'password',
11875        'port',
11876        'port_override',
11877        'secret_store_id',
11878        'tags',
11879        'username',
11880    ]
11881
11882    def __init__(
11883        self,
11884        bind_interface=None,
11885        egress_filter=None,
11886        healthy=None,
11887        hostname=None,
11888        id=None,
11889        name=None,
11890        password=None,
11891        port=None,
11892        port_override=None,
11893        secret_store_id=None,
11894        tags=None,
11895        username=None,
11896    ):
11897        self.bind_interface = bind_interface if bind_interface is not None else ''
11898        '''
11899         Bind interface
11900        '''
11901        self.egress_filter = egress_filter if egress_filter is not None else ''
11902        '''
11903         A filter applied to the routing logic to pin datasource to nodes.
11904        '''
11905        self.healthy = healthy if healthy is not None else False
11906        '''
11907         True if the datasource is reachable and the credentials are valid.
11908        '''
11909        self.hostname = hostname if hostname is not None else ''
11910        self.id = id if id is not None else ''
11911        '''
11912         Unique identifier of the Resource.
11913        '''
11914        self.name = name if name is not None else ''
11915        '''
11916         Unique human-readable name of the Resource.
11917        '''
11918        self.password = password if password is not None else ''
11919        self.port = port if port is not None else 0
11920        self.port_override = port_override if port_override is not None else 0
11921        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11922        '''
11923         ID of the secret store containing credentials for this resource, if any.
11924        '''
11925        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11926        '''
11927         Tags is a map of key, value pairs.
11928        '''
11929        self.username = username if username is not None else ''
11930
11931    def __repr__(self):
11932        return '<sdm.Sybase ' + \
11933            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11934            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11935            'healthy: ' + repr(self.healthy) + ' ' +\
11936            'hostname: ' + repr(self.hostname) + ' ' +\
11937            'id: ' + repr(self.id) + ' ' +\
11938            'name: ' + repr(self.name) + ' ' +\
11939            'password: ' + repr(self.password) + ' ' +\
11940            'port: ' + repr(self.port) + ' ' +\
11941            'port_override: ' + repr(self.port_override) + ' ' +\
11942            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11943            'tags: ' + repr(self.tags) + ' ' +\
11944            'username: ' + repr(self.username) + ' ' +\
11945            '>'
11946
11947    def to_dict(self):
11948        return {
11949            'bind_interface': self.bind_interface,
11950            'egress_filter': self.egress_filter,
11951            'healthy': self.healthy,
11952            'hostname': self.hostname,
11953            'id': self.id,
11954            'name': self.name,
11955            'password': self.password,
11956            'port': self.port,
11957            'port_override': self.port_override,
11958            'secret_store_id': self.secret_store_id,
11959            'tags': self.tags,
11960            'username': self.username,
11961        }
11962
11963    @classmethod
11964    def from_dict(cls, d):
11965        return cls(
11966            bind_interface=d.get('bind_interface'),
11967            egress_filter=d.get('egress_filter'),
11968            healthy=d.get('healthy'),
11969            hostname=d.get('hostname'),
11970            id=d.get('id'),
11971            name=d.get('name'),
11972            password=d.get('password'),
11973            port=d.get('port'),
11974            port_override=d.get('port_override'),
11975            secret_store_id=d.get('secret_store_id'),
11976            tags=d.get('tags'),
11977            username=d.get('username'),
11978        )
Sybase( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
11882    def __init__(
11883        self,
11884        bind_interface=None,
11885        egress_filter=None,
11886        healthy=None,
11887        hostname=None,
11888        id=None,
11889        name=None,
11890        password=None,
11891        port=None,
11892        port_override=None,
11893        secret_store_id=None,
11894        tags=None,
11895        username=None,
11896    ):
11897        self.bind_interface = bind_interface if bind_interface is not None else ''
11898        '''
11899         Bind interface
11900        '''
11901        self.egress_filter = egress_filter if egress_filter is not None else ''
11902        '''
11903         A filter applied to the routing logic to pin datasource to nodes.
11904        '''
11905        self.healthy = healthy if healthy is not None else False
11906        '''
11907         True if the datasource is reachable and the credentials are valid.
11908        '''
11909        self.hostname = hostname if hostname is not None else ''
11910        self.id = id if id is not None else ''
11911        '''
11912         Unique identifier of the Resource.
11913        '''
11914        self.name = name if name is not None else ''
11915        '''
11916         Unique human-readable name of the Resource.
11917        '''
11918        self.password = password if password is not None else ''
11919        self.port = port if port is not None else 0
11920        self.port_override = port_override if port_override is not None else 0
11921        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11922        '''
11923         ID of the secret store containing credentials for this resource, if any.
11924        '''
11925        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11926        '''
11927         Tags is a map of key, value pairs.
11928        '''
11929        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11947    def to_dict(self):
11948        return {
11949            'bind_interface': self.bind_interface,
11950            'egress_filter': self.egress_filter,
11951            'healthy': self.healthy,
11952            'hostname': self.hostname,
11953            'id': self.id,
11954            'name': self.name,
11955            'password': self.password,
11956            'port': self.port,
11957            'port_override': self.port_override,
11958            'secret_store_id': self.secret_store_id,
11959            'tags': self.tags,
11960            'username': self.username,
11961        }
@classmethod
def from_dict(cls, d)
11963    @classmethod
11964    def from_dict(cls, d):
11965        return cls(
11966            bind_interface=d.get('bind_interface'),
11967            egress_filter=d.get('egress_filter'),
11968            healthy=d.get('healthy'),
11969            hostname=d.get('hostname'),
11970            id=d.get('id'),
11971            name=d.get('name'),
11972            password=d.get('password'),
11973            port=d.get('port'),
11974            port_override=d.get('port_override'),
11975            secret_store_id=d.get('secret_store_id'),
11976            tags=d.get('tags'),
11977            username=d.get('username'),
11978        )
class SybaseIQ:
11981class SybaseIQ:
11982    __slots__ = [
11983        'bind_interface',
11984        'egress_filter',
11985        'healthy',
11986        'hostname',
11987        'id',
11988        'name',
11989        'password',
11990        'port',
11991        'port_override',
11992        'secret_store_id',
11993        'tags',
11994        'username',
11995    ]
11996
11997    def __init__(
11998        self,
11999        bind_interface=None,
12000        egress_filter=None,
12001        healthy=None,
12002        hostname=None,
12003        id=None,
12004        name=None,
12005        password=None,
12006        port=None,
12007        port_override=None,
12008        secret_store_id=None,
12009        tags=None,
12010        username=None,
12011    ):
12012        self.bind_interface = bind_interface if bind_interface is not None else ''
12013        '''
12014         Bind interface
12015        '''
12016        self.egress_filter = egress_filter if egress_filter is not None else ''
12017        '''
12018         A filter applied to the routing logic to pin datasource to nodes.
12019        '''
12020        self.healthy = healthy if healthy is not None else False
12021        '''
12022         True if the datasource is reachable and the credentials are valid.
12023        '''
12024        self.hostname = hostname if hostname is not None else ''
12025        self.id = id if id is not None else ''
12026        '''
12027         Unique identifier of the Resource.
12028        '''
12029        self.name = name if name is not None else ''
12030        '''
12031         Unique human-readable name of the Resource.
12032        '''
12033        self.password = password if password is not None else ''
12034        self.port = port if port is not None else 0
12035        self.port_override = port_override if port_override is not None else 0
12036        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12037        '''
12038         ID of the secret store containing credentials for this resource, if any.
12039        '''
12040        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12041        '''
12042         Tags is a map of key, value pairs.
12043        '''
12044        self.username = username if username is not None else ''
12045
12046    def __repr__(self):
12047        return '<sdm.SybaseIQ ' + \
12048            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12049            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12050            'healthy: ' + repr(self.healthy) + ' ' +\
12051            'hostname: ' + repr(self.hostname) + ' ' +\
12052            'id: ' + repr(self.id) + ' ' +\
12053            'name: ' + repr(self.name) + ' ' +\
12054            'password: ' + repr(self.password) + ' ' +\
12055            'port: ' + repr(self.port) + ' ' +\
12056            'port_override: ' + repr(self.port_override) + ' ' +\
12057            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12058            'tags: ' + repr(self.tags) + ' ' +\
12059            'username: ' + repr(self.username) + ' ' +\
12060            '>'
12061
12062    def to_dict(self):
12063        return {
12064            'bind_interface': self.bind_interface,
12065            'egress_filter': self.egress_filter,
12066            'healthy': self.healthy,
12067            'hostname': self.hostname,
12068            'id': self.id,
12069            'name': self.name,
12070            'password': self.password,
12071            'port': self.port,
12072            'port_override': self.port_override,
12073            'secret_store_id': self.secret_store_id,
12074            'tags': self.tags,
12075            'username': self.username,
12076        }
12077
12078    @classmethod
12079    def from_dict(cls, d):
12080        return cls(
12081            bind_interface=d.get('bind_interface'),
12082            egress_filter=d.get('egress_filter'),
12083            healthy=d.get('healthy'),
12084            hostname=d.get('hostname'),
12085            id=d.get('id'),
12086            name=d.get('name'),
12087            password=d.get('password'),
12088            port=d.get('port'),
12089            port_override=d.get('port_override'),
12090            secret_store_id=d.get('secret_store_id'),
12091            tags=d.get('tags'),
12092            username=d.get('username'),
12093        )
SybaseIQ( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
11997    def __init__(
11998        self,
11999        bind_interface=None,
12000        egress_filter=None,
12001        healthy=None,
12002        hostname=None,
12003        id=None,
12004        name=None,
12005        password=None,
12006        port=None,
12007        port_override=None,
12008        secret_store_id=None,
12009        tags=None,
12010        username=None,
12011    ):
12012        self.bind_interface = bind_interface if bind_interface is not None else ''
12013        '''
12014         Bind interface
12015        '''
12016        self.egress_filter = egress_filter if egress_filter is not None else ''
12017        '''
12018         A filter applied to the routing logic to pin datasource to nodes.
12019        '''
12020        self.healthy = healthy if healthy is not None else False
12021        '''
12022         True if the datasource is reachable and the credentials are valid.
12023        '''
12024        self.hostname = hostname if hostname is not None else ''
12025        self.id = id if id is not None else ''
12026        '''
12027         Unique identifier of the Resource.
12028        '''
12029        self.name = name if name is not None else ''
12030        '''
12031         Unique human-readable name of the Resource.
12032        '''
12033        self.password = password if password is not None else ''
12034        self.port = port if port is not None else 0
12035        self.port_override = port_override if port_override is not None else 0
12036        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12037        '''
12038         ID of the secret store containing credentials for this resource, if any.
12039        '''
12040        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12041        '''
12042         Tags is a map of key, value pairs.
12043        '''
12044        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
12062    def to_dict(self):
12063        return {
12064            'bind_interface': self.bind_interface,
12065            'egress_filter': self.egress_filter,
12066            'healthy': self.healthy,
12067            'hostname': self.hostname,
12068            'id': self.id,
12069            'name': self.name,
12070            'password': self.password,
12071            'port': self.port,
12072            'port_override': self.port_override,
12073            'secret_store_id': self.secret_store_id,
12074            'tags': self.tags,
12075            'username': self.username,
12076        }
@classmethod
def from_dict(cls, d)
12078    @classmethod
12079    def from_dict(cls, d):
12080        return cls(
12081            bind_interface=d.get('bind_interface'),
12082            egress_filter=d.get('egress_filter'),
12083            healthy=d.get('healthy'),
12084            hostname=d.get('hostname'),
12085            id=d.get('id'),
12086            name=d.get('name'),
12087            password=d.get('password'),
12088            port=d.get('port'),
12089            port_override=d.get('port_override'),
12090            secret_store_id=d.get('secret_store_id'),
12091            tags=d.get('tags'),
12092            username=d.get('username'),
12093        )
class Tag:
12096class Tag:
12097    __slots__ = [
12098        'name',
12099        'value',
12100    ]
12101
12102    def __init__(
12103        self,
12104        name=None,
12105        value=None,
12106    ):
12107        self.name = name if name is not None else ''
12108        self.value = value if value is not None else ''
12109
12110    def __repr__(self):
12111        return '<sdm.Tag ' + \
12112            'name: ' + repr(self.name) + ' ' +\
12113            'value: ' + repr(self.value) + ' ' +\
12114            '>'
12115
12116    def to_dict(self):
12117        return {
12118            'name': self.name,
12119            'value': self.value,
12120        }
12121
12122    @classmethod
12123    def from_dict(cls, d):
12124        return cls(
12125            name=d.get('name'),
12126            value=d.get('value'),
12127        )
Tag(name=None, value=None)
12102    def __init__(
12103        self,
12104        name=None,
12105        value=None,
12106    ):
12107        self.name = name if name is not None else ''
12108        self.value = value if value is not None else ''
name
value
def to_dict(self)
12116    def to_dict(self):
12117        return {
12118            'name': self.name,
12119            'value': self.value,
12120        }
@classmethod
def from_dict(cls, d)
12122    @classmethod
12123    def from_dict(cls, d):
12124        return cls(
12125            name=d.get('name'),
12126            value=d.get('value'),
12127        )
class Teradata:
12130class Teradata:
12131    __slots__ = [
12132        'bind_interface',
12133        'egress_filter',
12134        'healthy',
12135        'hostname',
12136        'id',
12137        'name',
12138        'password',
12139        'port',
12140        'port_override',
12141        'secret_store_id',
12142        'tags',
12143        'username',
12144    ]
12145
12146    def __init__(
12147        self,
12148        bind_interface=None,
12149        egress_filter=None,
12150        healthy=None,
12151        hostname=None,
12152        id=None,
12153        name=None,
12154        password=None,
12155        port=None,
12156        port_override=None,
12157        secret_store_id=None,
12158        tags=None,
12159        username=None,
12160    ):
12161        self.bind_interface = bind_interface if bind_interface is not None else ''
12162        '''
12163         Bind interface
12164        '''
12165        self.egress_filter = egress_filter if egress_filter is not None else ''
12166        '''
12167         A filter applied to the routing logic to pin datasource to nodes.
12168        '''
12169        self.healthy = healthy if healthy is not None else False
12170        '''
12171         True if the datasource is reachable and the credentials are valid.
12172        '''
12173        self.hostname = hostname if hostname is not None else ''
12174        self.id = id if id is not None else ''
12175        '''
12176         Unique identifier of the Resource.
12177        '''
12178        self.name = name if name is not None else ''
12179        '''
12180         Unique human-readable name of the Resource.
12181        '''
12182        self.password = password if password is not None else ''
12183        self.port = port if port is not None else 0
12184        self.port_override = port_override if port_override is not None else 0
12185        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12186        '''
12187         ID of the secret store containing credentials for this resource, if any.
12188        '''
12189        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12190        '''
12191         Tags is a map of key, value pairs.
12192        '''
12193        self.username = username if username is not None else ''
12194
12195    def __repr__(self):
12196        return '<sdm.Teradata ' + \
12197            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12198            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12199            'healthy: ' + repr(self.healthy) + ' ' +\
12200            'hostname: ' + repr(self.hostname) + ' ' +\
12201            'id: ' + repr(self.id) + ' ' +\
12202            'name: ' + repr(self.name) + ' ' +\
12203            'password: ' + repr(self.password) + ' ' +\
12204            'port: ' + repr(self.port) + ' ' +\
12205            'port_override: ' + repr(self.port_override) + ' ' +\
12206            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12207            'tags: ' + repr(self.tags) + ' ' +\
12208            'username: ' + repr(self.username) + ' ' +\
12209            '>'
12210
12211    def to_dict(self):
12212        return {
12213            'bind_interface': self.bind_interface,
12214            'egress_filter': self.egress_filter,
12215            'healthy': self.healthy,
12216            'hostname': self.hostname,
12217            'id': self.id,
12218            'name': self.name,
12219            'password': self.password,
12220            'port': self.port,
12221            'port_override': self.port_override,
12222            'secret_store_id': self.secret_store_id,
12223            'tags': self.tags,
12224            'username': self.username,
12225        }
12226
12227    @classmethod
12228    def from_dict(cls, d):
12229        return cls(
12230            bind_interface=d.get('bind_interface'),
12231            egress_filter=d.get('egress_filter'),
12232            healthy=d.get('healthy'),
12233            hostname=d.get('hostname'),
12234            id=d.get('id'),
12235            name=d.get('name'),
12236            password=d.get('password'),
12237            port=d.get('port'),
12238            port_override=d.get('port_override'),
12239            secret_store_id=d.get('secret_store_id'),
12240            tags=d.get('tags'),
12241            username=d.get('username'),
12242        )
Teradata( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
12146    def __init__(
12147        self,
12148        bind_interface=None,
12149        egress_filter=None,
12150        healthy=None,
12151        hostname=None,
12152        id=None,
12153        name=None,
12154        password=None,
12155        port=None,
12156        port_override=None,
12157        secret_store_id=None,
12158        tags=None,
12159        username=None,
12160    ):
12161        self.bind_interface = bind_interface if bind_interface is not None else ''
12162        '''
12163         Bind interface
12164        '''
12165        self.egress_filter = egress_filter if egress_filter is not None else ''
12166        '''
12167         A filter applied to the routing logic to pin datasource to nodes.
12168        '''
12169        self.healthy = healthy if healthy is not None else False
12170        '''
12171         True if the datasource is reachable and the credentials are valid.
12172        '''
12173        self.hostname = hostname if hostname is not None else ''
12174        self.id = id if id is not None else ''
12175        '''
12176         Unique identifier of the Resource.
12177        '''
12178        self.name = name if name is not None else ''
12179        '''
12180         Unique human-readable name of the Resource.
12181        '''
12182        self.password = password if password is not None else ''
12183        self.port = port if port is not None else 0
12184        self.port_override = port_override if port_override is not None else 0
12185        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12186        '''
12187         ID of the secret store containing credentials for this resource, if any.
12188        '''
12189        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12190        '''
12191         Tags is a map of key, value pairs.
12192        '''
12193        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
12211    def to_dict(self):
12212        return {
12213            'bind_interface': self.bind_interface,
12214            'egress_filter': self.egress_filter,
12215            'healthy': self.healthy,
12216            'hostname': self.hostname,
12217            'id': self.id,
12218            'name': self.name,
12219            'password': self.password,
12220            'port': self.port,
12221            'port_override': self.port_override,
12222            'secret_store_id': self.secret_store_id,
12223            'tags': self.tags,
12224            'username': self.username,
12225        }
@classmethod
def from_dict(cls, d)
12227    @classmethod
12228    def from_dict(cls, d):
12229        return cls(
12230            bind_interface=d.get('bind_interface'),
12231            egress_filter=d.get('egress_filter'),
12232            healthy=d.get('healthy'),
12233            hostname=d.get('hostname'),
12234            id=d.get('id'),
12235            name=d.get('name'),
12236            password=d.get('password'),
12237            port=d.get('port'),
12238            port_override=d.get('port_override'),
12239            secret_store_id=d.get('secret_store_id'),
12240            tags=d.get('tags'),
12241            username=d.get('username'),
12242        )
class UpdateResponseMetadata:
12245class UpdateResponseMetadata:
12246    '''
12247         UpdateResponseMetadata is reserved for future use.
12248    '''
12249    __slots__ = []
12250
12251    def __init__(self, ):
12252        pass
12253
12254    def __repr__(self):
12255        return '<sdm.UpdateResponseMetadata ' + \
12256            '>'
12257
12258    def to_dict(self):
12259        return {}
12260
12261    @classmethod
12262    def from_dict(cls, d):
12263        return cls()

UpdateResponseMetadata is reserved for future use.

UpdateResponseMetadata()
12251    def __init__(self, ):
12252        pass
def to_dict(self)
12258    def to_dict(self):
12259        return {}
@classmethod
def from_dict(cls, d)
12261    @classmethod
12262    def from_dict(cls, d):
12263        return cls()
class User:
12266class User:
12267    '''
12268         A User can connect to resources they are granted directly, or granted
12269     via roles.
12270    '''
12271    __slots__ = [
12272        'email',
12273        'external_id',
12274        'first_name',
12275        'id',
12276        'last_name',
12277        'managed_by',
12278        'permission_level',
12279        'suspended',
12280        'tags',
12281    ]
12282
12283    def __init__(
12284        self,
12285        email=None,
12286        external_id=None,
12287        first_name=None,
12288        id=None,
12289        last_name=None,
12290        managed_by=None,
12291        permission_level=None,
12292        suspended=None,
12293        tags=None,
12294    ):
12295        self.email = email if email is not None else ''
12296        '''
12297         The User's email address. Must be unique.
12298        '''
12299        self.external_id = external_id if external_id is not None else ''
12300        '''
12301         External ID is an alternative unique ID this user is represented by within an external service.
12302        '''
12303        self.first_name = first_name if first_name is not None else ''
12304        '''
12305         The User's first name.
12306        '''
12307        self.id = id if id is not None else ''
12308        '''
12309         Unique identifier of the User.
12310        '''
12311        self.last_name = last_name if last_name is not None else ''
12312        '''
12313         The User's last name.
12314        '''
12315        self.managed_by = managed_by if managed_by is not None else ''
12316        '''
12317         Managed By is a read only field for what service manages this user, e.g. StrongDM, Okta, Azure.
12318        '''
12319        self.permission_level = permission_level if permission_level is not None else ''
12320        '''
12321         PermissionLevel is a read only field for the user's permission level e.g. admin, DBA, user.
12322        '''
12323        self.suspended = suspended if suspended is not None else False
12324        '''
12325         The User's suspended state.
12326        '''
12327        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12328        '''
12329         Tags is a map of key, value pairs.
12330        '''
12331
12332    def __repr__(self):
12333        return '<sdm.User ' + \
12334            'email: ' + repr(self.email) + ' ' +\
12335            'external_id: ' + repr(self.external_id) + ' ' +\
12336            'first_name: ' + repr(self.first_name) + ' ' +\
12337            'id: ' + repr(self.id) + ' ' +\
12338            'last_name: ' + repr(self.last_name) + ' ' +\
12339            'managed_by: ' + repr(self.managed_by) + ' ' +\
12340            'permission_level: ' + repr(self.permission_level) + ' ' +\
12341            'suspended: ' + repr(self.suspended) + ' ' +\
12342            'tags: ' + repr(self.tags) + ' ' +\
12343            '>'
12344
12345    def to_dict(self):
12346        return {
12347            'email': self.email,
12348            'external_id': self.external_id,
12349            'first_name': self.first_name,
12350            'id': self.id,
12351            'last_name': self.last_name,
12352            'managed_by': self.managed_by,
12353            'permission_level': self.permission_level,
12354            'suspended': self.suspended,
12355            'tags': self.tags,
12356        }
12357
12358    @classmethod
12359    def from_dict(cls, d):
12360        return cls(
12361            email=d.get('email'),
12362            external_id=d.get('external_id'),
12363            first_name=d.get('first_name'),
12364            id=d.get('id'),
12365            last_name=d.get('last_name'),
12366            managed_by=d.get('managed_by'),
12367            permission_level=d.get('permission_level'),
12368            suspended=d.get('suspended'),
12369            tags=d.get('tags'),
12370        )

A User can connect to resources they are granted directly, or granted via roles.

User( email=None, external_id=None, first_name=None, id=None, last_name=None, managed_by=None, permission_level=None, suspended=None, tags=None)
12283    def __init__(
12284        self,
12285        email=None,
12286        external_id=None,
12287        first_name=None,
12288        id=None,
12289        last_name=None,
12290        managed_by=None,
12291        permission_level=None,
12292        suspended=None,
12293        tags=None,
12294    ):
12295        self.email = email if email is not None else ''
12296        '''
12297         The User's email address. Must be unique.
12298        '''
12299        self.external_id = external_id if external_id is not None else ''
12300        '''
12301         External ID is an alternative unique ID this user is represented by within an external service.
12302        '''
12303        self.first_name = first_name if first_name is not None else ''
12304        '''
12305         The User's first name.
12306        '''
12307        self.id = id if id is not None else ''
12308        '''
12309         Unique identifier of the User.
12310        '''
12311        self.last_name = last_name if last_name is not None else ''
12312        '''
12313         The User's last name.
12314        '''
12315        self.managed_by = managed_by if managed_by is not None else ''
12316        '''
12317         Managed By is a read only field for what service manages this user, e.g. StrongDM, Okta, Azure.
12318        '''
12319        self.permission_level = permission_level if permission_level is not None else ''
12320        '''
12321         PermissionLevel is a read only field for the user's permission level e.g. admin, DBA, user.
12322        '''
12323        self.suspended = suspended if suspended is not None else False
12324        '''
12325         The User's suspended state.
12326        '''
12327        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12328        '''
12329         Tags is a map of key, value pairs.
12330        '''
email

The User's email address. Must be unique.

external_id

External ID is an alternative unique ID this user is represented by within an external service.

first_name

The User's first name.

id

Unique identifier of the User.

last_name

The User's last name.

managed_by

Managed By is a read only field for what service manages this user, e.g. StrongDM, Okta, Azure.

permission_level

PermissionLevel is a read only field for the user's permission level e.g. admin, DBA, user.

suspended

The User's suspended state.

tags

Tags is a map of key, value pairs.

def to_dict(self)
12345    def to_dict(self):
12346        return {
12347            'email': self.email,
12348            'external_id': self.external_id,
12349            'first_name': self.first_name,
12350            'id': self.id,
12351            'last_name': self.last_name,
12352            'managed_by': self.managed_by,
12353            'permission_level': self.permission_level,
12354            'suspended': self.suspended,
12355            'tags': self.tags,
12356        }
@classmethod
def from_dict(cls, d)
12358    @classmethod
12359    def from_dict(cls, d):
12360        return cls(
12361            email=d.get('email'),
12362            external_id=d.get('external_id'),
12363            first_name=d.get('first_name'),
12364            id=d.get('id'),
12365            last_name=d.get('last_name'),
12366            managed_by=d.get('managed_by'),
12367            permission_level=d.get('permission_level'),
12368            suspended=d.get('suspended'),
12369            tags=d.get('tags'),
12370        )
class VaultAppRoleStore:
12373class VaultAppRoleStore:
12374    __slots__ = [
12375        'id',
12376        'name',
12377        'namespace',
12378        'server_address',
12379        'tags',
12380    ]
12381
12382    def __init__(
12383        self,
12384        id=None,
12385        name=None,
12386        namespace=None,
12387        server_address=None,
12388        tags=None,
12389    ):
12390        self.id = id if id is not None else ''
12391        '''
12392         Unique identifier of the SecretStore.
12393        '''
12394        self.name = name if name is not None else ''
12395        '''
12396         Unique human-readable name of the SecretStore.
12397        '''
12398        self.namespace = namespace if namespace is not None else ''
12399        self.server_address = server_address if server_address is not None else ''
12400        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12401        '''
12402         Tags is a map of key, value pairs.
12403        '''
12404
12405    def __repr__(self):
12406        return '<sdm.VaultAppRoleStore ' + \
12407            'id: ' + repr(self.id) + ' ' +\
12408            'name: ' + repr(self.name) + ' ' +\
12409            'namespace: ' + repr(self.namespace) + ' ' +\
12410            'server_address: ' + repr(self.server_address) + ' ' +\
12411            'tags: ' + repr(self.tags) + ' ' +\
12412            '>'
12413
12414    def to_dict(self):
12415        return {
12416            'id': self.id,
12417            'name': self.name,
12418            'namespace': self.namespace,
12419            'server_address': self.server_address,
12420            'tags': self.tags,
12421        }
12422
12423    @classmethod
12424    def from_dict(cls, d):
12425        return cls(
12426            id=d.get('id'),
12427            name=d.get('name'),
12428            namespace=d.get('namespace'),
12429            server_address=d.get('server_address'),
12430            tags=d.get('tags'),
12431        )
VaultAppRoleStore(id=None, name=None, namespace=None, server_address=None, tags=None)
12382    def __init__(
12383        self,
12384        id=None,
12385        name=None,
12386        namespace=None,
12387        server_address=None,
12388        tags=None,
12389    ):
12390        self.id = id if id is not None else ''
12391        '''
12392         Unique identifier of the SecretStore.
12393        '''
12394        self.name = name if name is not None else ''
12395        '''
12396         Unique human-readable name of the SecretStore.
12397        '''
12398        self.namespace = namespace if namespace is not None else ''
12399        self.server_address = server_address if server_address is not None else ''
12400        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12401        '''
12402         Tags is a map of key, value pairs.
12403        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
12414    def to_dict(self):
12415        return {
12416            'id': self.id,
12417            'name': self.name,
12418            'namespace': self.namespace,
12419            'server_address': self.server_address,
12420            'tags': self.tags,
12421        }
@classmethod
def from_dict(cls, d)
12423    @classmethod
12424    def from_dict(cls, d):
12425        return cls(
12426            id=d.get('id'),
12427            name=d.get('name'),
12428            namespace=d.get('namespace'),
12429            server_address=d.get('server_address'),
12430            tags=d.get('tags'),
12431        )
class VaultTLSStore:
12434class VaultTLSStore:
12435    __slots__ = [
12436        'ca_cert_path',
12437        'client_cert_path',
12438        'client_key_path',
12439        'id',
12440        'name',
12441        'namespace',
12442        'server_address',
12443        'tags',
12444    ]
12445
12446    def __init__(
12447        self,
12448        ca_cert_path=None,
12449        client_cert_path=None,
12450        client_key_path=None,
12451        id=None,
12452        name=None,
12453        namespace=None,
12454        server_address=None,
12455        tags=None,
12456    ):
12457        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
12458        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
12459        self.client_key_path = client_key_path if client_key_path is not None else ''
12460        self.id = id if id is not None else ''
12461        '''
12462         Unique identifier of the SecretStore.
12463        '''
12464        self.name = name if name is not None else ''
12465        '''
12466         Unique human-readable name of the SecretStore.
12467        '''
12468        self.namespace = namespace if namespace is not None else ''
12469        self.server_address = server_address if server_address is not None else ''
12470        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12471        '''
12472         Tags is a map of key, value pairs.
12473        '''
12474
12475    def __repr__(self):
12476        return '<sdm.VaultTLSStore ' + \
12477            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
12478            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
12479            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
12480            'id: ' + repr(self.id) + ' ' +\
12481            'name: ' + repr(self.name) + ' ' +\
12482            'namespace: ' + repr(self.namespace) + ' ' +\
12483            'server_address: ' + repr(self.server_address) + ' ' +\
12484            'tags: ' + repr(self.tags) + ' ' +\
12485            '>'
12486
12487    def to_dict(self):
12488        return {
12489            'ca_cert_path': self.ca_cert_path,
12490            'client_cert_path': self.client_cert_path,
12491            'client_key_path': self.client_key_path,
12492            'id': self.id,
12493            'name': self.name,
12494            'namespace': self.namespace,
12495            'server_address': self.server_address,
12496            'tags': self.tags,
12497        }
12498
12499    @classmethod
12500    def from_dict(cls, d):
12501        return cls(
12502            ca_cert_path=d.get('ca_cert_path'),
12503            client_cert_path=d.get('client_cert_path'),
12504            client_key_path=d.get('client_key_path'),
12505            id=d.get('id'),
12506            name=d.get('name'),
12507            namespace=d.get('namespace'),
12508            server_address=d.get('server_address'),
12509            tags=d.get('tags'),
12510        )
VaultTLSStore( ca_cert_path=None, client_cert_path=None, client_key_path=None, id=None, name=None, namespace=None, server_address=None, tags=None)
12446    def __init__(
12447        self,
12448        ca_cert_path=None,
12449        client_cert_path=None,
12450        client_key_path=None,
12451        id=None,
12452        name=None,
12453        namespace=None,
12454        server_address=None,
12455        tags=None,
12456    ):
12457        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
12458        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
12459        self.client_key_path = client_key_path if client_key_path is not None else ''
12460        self.id = id if id is not None else ''
12461        '''
12462         Unique identifier of the SecretStore.
12463        '''
12464        self.name = name if name is not None else ''
12465        '''
12466         Unique human-readable name of the SecretStore.
12467        '''
12468        self.namespace = namespace if namespace is not None else ''
12469        self.server_address = server_address if server_address is not None else ''
12470        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12471        '''
12472         Tags is a map of key, value pairs.
12473        '''
ca_cert_path
client_cert_path
client_key_path
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
12487    def to_dict(self):
12488        return {
12489            'ca_cert_path': self.ca_cert_path,
12490            'client_cert_path': self.client_cert_path,
12491            'client_key_path': self.client_key_path,
12492            'id': self.id,
12493            'name': self.name,
12494            'namespace': self.namespace,
12495            'server_address': self.server_address,
12496            'tags': self.tags,
12497        }
@classmethod
def from_dict(cls, d)
12499    @classmethod
12500    def from_dict(cls, d):
12501        return cls(
12502            ca_cert_path=d.get('ca_cert_path'),
12503            client_cert_path=d.get('client_cert_path'),
12504            client_key_path=d.get('client_key_path'),
12505            id=d.get('id'),
12506            name=d.get('name'),
12507            namespace=d.get('namespace'),
12508            server_address=d.get('server_address'),
12509            tags=d.get('tags'),
12510        )
class VaultTokenStore:
12513class VaultTokenStore:
12514    __slots__ = [
12515        'id',
12516        'name',
12517        'namespace',
12518        'server_address',
12519        'tags',
12520    ]
12521
12522    def __init__(
12523        self,
12524        id=None,
12525        name=None,
12526        namespace=None,
12527        server_address=None,
12528        tags=None,
12529    ):
12530        self.id = id if id is not None else ''
12531        '''
12532         Unique identifier of the SecretStore.
12533        '''
12534        self.name = name if name is not None else ''
12535        '''
12536         Unique human-readable name of the SecretStore.
12537        '''
12538        self.namespace = namespace if namespace is not None else ''
12539        self.server_address = server_address if server_address is not None else ''
12540        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12541        '''
12542         Tags is a map of key, value pairs.
12543        '''
12544
12545    def __repr__(self):
12546        return '<sdm.VaultTokenStore ' + \
12547            'id: ' + repr(self.id) + ' ' +\
12548            'name: ' + repr(self.name) + ' ' +\
12549            'namespace: ' + repr(self.namespace) + ' ' +\
12550            'server_address: ' + repr(self.server_address) + ' ' +\
12551            'tags: ' + repr(self.tags) + ' ' +\
12552            '>'
12553
12554    def to_dict(self):
12555        return {
12556            'id': self.id,
12557            'name': self.name,
12558            'namespace': self.namespace,
12559            'server_address': self.server_address,
12560            'tags': self.tags,
12561        }
12562
12563    @classmethod
12564    def from_dict(cls, d):
12565        return cls(
12566            id=d.get('id'),
12567            name=d.get('name'),
12568            namespace=d.get('namespace'),
12569            server_address=d.get('server_address'),
12570            tags=d.get('tags'),
12571        )
VaultTokenStore(id=None, name=None, namespace=None, server_address=None, tags=None)
12522    def __init__(
12523        self,
12524        id=None,
12525        name=None,
12526        namespace=None,
12527        server_address=None,
12528        tags=None,
12529    ):
12530        self.id = id if id is not None else ''
12531        '''
12532         Unique identifier of the SecretStore.
12533        '''
12534        self.name = name if name is not None else ''
12535        '''
12536         Unique human-readable name of the SecretStore.
12537        '''
12538        self.namespace = namespace if namespace is not None else ''
12539        self.server_address = server_address if server_address is not None else ''
12540        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12541        '''
12542         Tags is a map of key, value pairs.
12543        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
12554    def to_dict(self):
12555        return {
12556            'id': self.id,
12557            'name': self.name,
12558            'namespace': self.namespace,
12559            'server_address': self.server_address,
12560            'tags': self.tags,
12561        }
@classmethod
def from_dict(cls, d)
12563    @classmethod
12564    def from_dict(cls, d):
12565        return cls(
12566            id=d.get('id'),
12567            name=d.get('name'),
12568            namespace=d.get('namespace'),
12569            server_address=d.get('server_address'),
12570            tags=d.get('tags'),
12571        )